client.getChargesChargeRefundsRefund(charge, refund, { ...params }) -> Stripe.Refund
-
-
-
Retrieves the details of an existing refund.
-
-
-
await client.getChargesChargeRefundsRefund("charge", "refund");
-
-
-
charge:
string
-
refund:
string
-
request:
Stripe.GetChargesChargeRefundsRefundRequest
-
requestOptions:
StripeClient.RequestOptions
-
-
client.account.retrieve({ ...params }) -> Stripe.Account
-
-
-
Retrieves the details of an account.
-
-
-
await client.account.retrieve();
-
-
-
request:
Stripe.AccountRetrieveRequest
-
requestOptions:
Account.RequestOptions
-
-
client.account.list({ ...params }) -> Stripe.AccountListResponse
-
-
-
Returns a list of accounts connected to your platform via Connect. If you’re not a platform, the list is empty.
-
-
-
await client.account.list();
-
-
-
request:
Stripe.AccountListRequest
-
requestOptions:
Account.RequestOptions
-
-
client.account.create({ ...params }) -> Stripe.Account
-
-
-
With Connect, you can create Stripe accounts for your users. To do this, you’ll first need to register your platform.
If you’ve already collected information for your connected accounts, you can prefill that information when creating the account. Connect Onboarding won’t ask for the prefilled information during account onboarding. You can prefill any information on the account.
-
-
-
await client.account.create();
-
-
-
request:
Stripe.AccountCreateRequest
-
requestOptions:
Account.RequestOptions
-
-
client.account.update(account, { ...params }) -> Stripe.Account
-
-
-
Updates a connected account by setting the values of the parameters passed. Any parameters not provided are left unchanged.
For accounts where controller.requirement_collection is
application, which includes Custom accounts, you can update any information on the account.For accounts where controller.requirement_collection is
stripe, which includes Standard and Express accounts, you can update all information until you create an Account Link or Account Session to start Connect onboarding, after which some properties can no longer be updated.To update your own account, use the Dashboard. Refer to our Connect documentation to learn more about updating accounts.
-
-
-
await client.account.update("account");
-
-
-
account:
string
-
request:
Stripe.AccountUpdateRequest
-
requestOptions:
Account.RequestOptions
-
-
client.account.delete(account, { ...params }) -> Stripe.DeletedAccount
-
-
-
With Connect, you can delete accounts you manage.
Test-mode accounts can be deleted at any time.
Live-mode accounts where Stripe is responsible for negative account balances cannot be deleted, which includes Standard accounts. Live-mode accounts where your platform is liable for negative account balances, which includes Custom and Express accounts, can be deleted when all balances are zero.
If you want to delete your own account, use the account information tab in your account settings instead.
-
-
-
await client.account.delete("account");
-
-
-
account:
string
-
request:
Stripe.AccountDeleteRequest
-
requestOptions:
Account.RequestOptions
-
-
client.account.reject(account, { ...params }) -> Stripe.Account
-
-
-
With Connect, you can reject accounts that you have flagged as suspicious.
Only accounts where your platform is liable for negative account balances, which includes Custom and Express accounts, can be rejected. Test-mode accounts can be rejected at any time. Live-mode accounts can only be rejected after all balances are zero.
-
-
-
await client.account.reject("account", { reason: "reason", });
-
-
-
account:
string
-
request:
Stripe.AccountRejectRequest
-
requestOptions:
Account.RequestOptions
-
-
client.accountLink.create({ ...params }) -> Stripe.AccountLink
-
-
-
Creates an AccountLink object that includes a single-use Stripe URL that the platform can redirect their user to in order to take them through the Connect Onboarding flow.
-
-
-
await client.accountLink.create({ account: "account", type: "account_onboarding", });
-
-
-
request:
Stripe.AccountLinkCreateRequest
-
requestOptions:
AccountLink.RequestOptions
-
-
client.accountSession.create({ ...params }) -> Stripe.AccountSession
-
-
-
Creates a AccountSession object that includes a single-use token that the platform can use on their front-end to grant client-side API access.
-
-
-
await client.accountSession.create({ account: "account", components: {}, });
-
-
-
request:
Stripe.AccountSessionCreateRequest
-
requestOptions:
AccountSession.RequestOptions
-
-
client.capability.list(account, { ...params }) -> Stripe.CapabilityListResponse
-
-
-
Returns a list of capabilities associated with the account. The capabilities are returned sorted by creation date, with the most recent capability appearing first.
-
-
-
await client.capability.list("account");
-
-
-
account:
string
-
request:
Stripe.CapabilityListRequest
-
requestOptions:
Capability.RequestOptions
-
-
client.capability.retrieve(account, capability, { ...params }) -> Stripe.Capability
-
-
-
Retrieves information about the specified Account Capability.
-
-
-
await client.capability.retrieve("account", "capability");
-
-
-
account:
string
-
capability:
string
-
request:
Stripe.CapabilityRetrieveRequest
-
requestOptions:
Capability.RequestOptions
-
-
client.capability.update(account, capability, { ...params }) -> Stripe.Capability
-
-
-
Updates an existing Account Capability. Request or remove a capability by updating its
requestedparameter.
-
-
-
await client.capability.update("account", "capability");
-
-
-
account:
string
-
capability:
string
-
request:
Stripe.CapabilityUpdateRequest
-
requestOptions:
Capability.RequestOptions
-
-
client.externalAccount.list(account, { ...params }) -> Stripe.ExternalAccountListResponse
-
-
-
List external accounts for an account.
-
-
-
await client.externalAccount.list("account");
-
-
-
account:
string
-
request:
Stripe.ExternalAccountListRequest
-
requestOptions:
ExternalAccount.RequestOptions
-
-
client.externalAccount.create(account, { ...params }) -> Stripe.ExternalAccount
-
-
-
Create an external account for a given account.
-
-
-
await client.externalAccount.create("account", { external_account: "external_account", });
-
-
-
account:
string
-
request:
Stripe.ExternalAccountCreateRequest
-
requestOptions:
ExternalAccount.RequestOptions
-
-
client.externalAccount.retrieve(account, id, { ...params }) -> Stripe.ExternalAccount
-
-
-
Retrieve a specified external account for a given account.
-
-
-
await client.externalAccount.retrieve("account", "id");
-
-
-
account:
string
-
id:
string
-
request:
Stripe.ExternalAccountRetrieveRequest
-
requestOptions:
ExternalAccount.RequestOptions
-
-
client.externalAccount.update(account, id, { ...params }) -> Stripe.ExternalAccount
-
-
-
Updates the metadata, account holder name, account holder type of a bank account belonging to a connected account and optionally sets it as the default for its currency. Other bank account details are not editable by design.
You can only update bank accounts when account.controller.requirement_collection is
application, which includes Custom accounts.You can re-enable a disabled bank account by performing an update call without providing any arguments or changes.
-
-
-
await client.externalAccount.update("account", "id");
-
-
-
account:
string
-
id:
string
-
request:
Stripe.ExternalAccountUpdateRequest
-
requestOptions:
ExternalAccount.RequestOptions
-
-
client.externalAccount.delete(account, id, { ...params }) -> Stripe.DeletedExternalAccount
-
-
-
Delete a specified external account for a given account.
-
-
-
await client.externalAccount.delete("account", "id");
-
-
-
account:
string
-
id:
string
-
request:
Stripe.ExternalAccountDeleteRequest
-
requestOptions:
ExternalAccount.RequestOptions
-
-
client.loginLink.create(account, { ...params }) -> Stripe.LoginLink
-
-
-
Creates a login link for a connected account to access the Express Dashboard.
You can only create login links for accounts that use the Express Dashboard and are connected to your platform.
-
-
-
await client.loginLink.create("account");
-
-
-
account:
string
-
request:
Stripe.LoginLinkCreateRequest
-
requestOptions:
LoginLink.RequestOptions
-
-
client.person.list(account, { ...params }) -> Stripe.PersonListResponse
-
-
-
Returns a list of people associated with the account’s legal entity. The people are returned sorted by creation date, with the most recent people appearing first.
-
-
-
await client.person.list("account");
-
-
-
account:
string
-
request:
Stripe.PersonListRequest
-
requestOptions:
Person.RequestOptions
-
-
client.person.create(account, { ...params }) -> Stripe.Person
-
-
-
Creates a new person.
-
-
-
await client.person.create("account");
-
-
-
account:
string
-
request:
Stripe.PersonCreateRequest
-
requestOptions:
Person.RequestOptions
-
-
client.person.retrieve(account, person, { ...params }) -> Stripe.Person
-
-
-
Retrieves an existing person.
-
-
-
await client.person.retrieve("account", "person");
-
-
-
account:
string
-
person:
string
-
request:
Stripe.PersonRetrieveRequest
-
requestOptions:
Person.RequestOptions
-
-
client.person.update(account, person, { ...params }) -> Stripe.Person
-
-
-
Updates an existing person.
-
-
-
await client.person.update("account", "person");
-
-
-
account:
string
-
person:
string
-
request:
Stripe.PersonUpdateRequest
-
requestOptions:
Person.RequestOptions
-
-
client.person.delete(account, person, { ...params }) -> Stripe.DeletedPerson
-
-
-
Deletes an existing person’s relationship to the account’s legal entity. Any person with a relationship for an account can be deleted through the API, except if the person is the
account_opener. If your integration is using theexecutiveparameter, you cannot delete the only verifiedexecutiveon file.
-
-
-
await client.person.delete("account", "person");
-
-
-
account:
string
-
person:
string
-
request:
Stripe.PersonDeleteRequest
-
requestOptions:
Person.RequestOptions
-
-
client.applePayDomain.list({ ...params }) -> Stripe.ApplePayDomainListResponse
-
-
-
List apple pay domains.
-
-
-
await client.applePayDomain.list();
-
-
-
request:
Stripe.ApplePayDomainListRequest
-
requestOptions:
ApplePayDomain.RequestOptions
-
-
client.applePayDomain.create({ ...params }) -> Stripe.ApplePayDomain
-
-
-
Create an apple pay domain.
-
-
-
await client.applePayDomain.create({ domain_name: "domain_name", });
-
-
-
request:
Stripe.ApplePayDomainCreateRequest
-
requestOptions:
ApplePayDomain.RequestOptions
-
-
client.applePayDomain.retrieve(domain, { ...params }) -> Stripe.ApplePayDomain
-
-
-
Retrieve an apple pay domain.
-
-
-
await client.applePayDomain.retrieve("domain");
-
-
-
domain:
string
-
request:
Stripe.ApplePayDomainRetrieveRequest
-
requestOptions:
ApplePayDomain.RequestOptions
-
-
client.applePayDomain.delete(domain, { ...params }) -> Stripe.DeletedApplePayDomain
-
-
-
Delete an apple pay domain.
-
-
-
await client.applePayDomain.delete("domain");
-
-
-
domain:
string
-
request:
Stripe.ApplePayDomainDeleteRequest
-
requestOptions:
ApplePayDomain.RequestOptions
-
-
client.applicationFee.list({ ...params }) -> Stripe.ApplicationFeeListResponse
-
-
-
Returns a list of application fees you’ve previously collected. The application fees are returned in sorted order, with the most recent fees appearing first.
-
-
-
await client.applicationFee.list();
-
-
-
request:
Stripe.ApplicationFeeListRequest
-
requestOptions:
ApplicationFee.RequestOptions
-
-
client.applicationFee.retrieve(id, { ...params }) -> Stripe.ApplicationFee
-
-
-
Retrieves the details of an application fee that your account has collected. The same information is returned when refunding the application fee.
-
-
-
await client.applicationFee.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.ApplicationFeeRetrieveRequest
-
requestOptions:
ApplicationFee.RequestOptions
-
-
client.feeRefund.retrieve(fee, id, { ...params }) -> Stripe.FeeRefund
-
-
-
By default, you can see the 10 most recent refunds stored directly on the application fee object, but you can also retrieve details about a specific refund stored on the application fee.
-
-
-
await client.feeRefund.retrieve("fee", "id");
-
-
-
fee:
string
-
id:
string
-
request:
Stripe.FeeRefundRetrieveRequest
-
requestOptions:
FeeRefund.RequestOptions
-
-
client.feeRefund.update(fee, id, { ...params }) -> Stripe.FeeRefund
-
-
-
Updates the specified application fee refund by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
This request only accepts metadata as an argument.
-
-
-
await client.feeRefund.update("fee", "id");
-
-
-
fee:
string
-
id:
string
-
request:
Stripe.FeeRefundUpdateRequest
-
requestOptions:
FeeRefund.RequestOptions
-
-
client.feeRefund.list(id, { ...params }) -> Stripe.FeeRefundListResponse
-
-
-
You can see a list of the refunds belonging to a specific application fee. Note that the 10 most recent refunds are always available by default on the application fee object. If you need more than those 10, you can use this API method and the
limitandstarting_afterparameters to page through additional refunds.
-
-
-
await client.feeRefund.list("id");
-
-
-
id:
string
-
request:
Stripe.FeeRefundListRequest
-
requestOptions:
FeeRefund.RequestOptions
-
-
client.feeRefund.create(id, { ...params }) -> Stripe.FeeRefund
-
-
-
Refunds an application fee that has previously been collected but not yet refunded. Funds will be refunded to the Stripe account from which the fee was originally collected.
You can optionally refund only part of an application fee. You can do so multiple times, until the entire fee has been refunded.
Once entirely refunded, an application fee can’t be refunded again. This method will raise an error when called on an already-refunded application fee, or when trying to refund more money than is left on an application fee.
-
-
-
await client.feeRefund.create("id");
-
-
-
id:
string
-
request:
Stripe.FeeRefundCreateRequest
-
requestOptions:
FeeRefund.RequestOptions
-
-
client.balance.retrieve({ ...params }) -> Stripe.Balance
-
-
-
Retrieves the current account balance, based on the authentication that was used to make the request. For a sample request, see Accounting for negative balances.
-
-
-
await client.balance.retrieve();
-
-
-
request:
Stripe.BalanceRetrieveRequest
-
requestOptions:
Balance.RequestOptions
-
-
client.balanceTransaction.list({ ...params }) -> Stripe.BalanceTransactionListResponse
-
-
-
Returns a list of transactions that have contributed to the Stripe account balance (e.g., charges, transfers, and so forth). The transactions are returned in sorted order, with the most recent transactions appearing first.
Note that this endpoint was previously called “Balance history” and used the path
/v1/balance/history.
-
-
-
await client.balanceTransaction.list();
-
-
-
request:
Stripe.BalanceTransactionListRequest
-
requestOptions:
BalanceTransaction.RequestOptions
-
-
client.balanceTransaction.retrieve(id, { ...params }) -> Stripe.BalanceTransaction
-
-
-
Retrieves the balance transaction with the given ID.
Note that this endpoint previously used the path
/v1/balance/history/:id.
-
-
-
await client.balanceTransaction.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.BalanceTransactionRetrieveRequest
-
requestOptions:
BalanceTransaction.RequestOptions
-
-
client.charge.list({ ...params }) -> Stripe.ChargeListResponse
-
-
-
Returns a list of charges you’ve previously created. The charges are returned in sorted order, with the most recent charges appearing first.
-
-
-
await client.charge.list();
-
-
-
request:
Stripe.ChargeListRequest
-
requestOptions:
Charge.RequestOptions
-
-
client.charge.create({ ...params }) -> Stripe.Charge
-
-
-
This method is no longer recommended—use the Payment Intents API to initiate a new payment instead. Confirmation of the PaymentIntent creates the
Chargeobject used to request payment.
-
-
-
await client.charge.create();
-
-
-
request:
Stripe.ChargeCreateRequest
-
requestOptions:
Charge.RequestOptions
-
-
client.charge.search({ ...params }) -> Stripe.ChargeSearchResponse
-
-
-
Search for charges you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.charge.search({ query: "query", });
-
-
-
request:
Stripe.ChargeSearchRequest
-
requestOptions:
Charge.RequestOptions
-
-
client.charge.retrieve(charge, { ...params }) -> Stripe.Charge
-
-
-
Retrieves the details of a charge that has previously been created. Supply the unique charge ID that was returned from your previous request, and Stripe will return the corresponding charge information. The same information is returned when creating or refunding the charge.
-
-
-
await client.charge.retrieve("charge");
-
-
-
charge:
string
-
request:
Stripe.ChargeRetrieveRequest
-
requestOptions:
Charge.RequestOptions
-
-
client.charge.update(charge, { ...params }) -> Stripe.Charge
-
-
-
Updates the specified charge by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.charge.update("charge");
-
-
-
charge:
string
-
request:
Stripe.ChargeUpdateRequest
-
requestOptions:
Charge.RequestOptions
-
-
client.charge.capture(charge, { ...params }) -> Stripe.Charge
-
-
-
Capture the payment of an existing, uncaptured charge that was created with the
captureoption set to false.Uncaptured payments expire a set number of days after they are created (7 by default), after which they are marked as refunded and capture attempts will fail.
Don’t use this method to capture a PaymentIntent-initiated charge. Use Capture a PaymentIntent.
-
-
-
await client.charge.capture("charge");
-
-
-
charge:
string
-
request:
Stripe.ChargeCaptureRequest
-
requestOptions:
Charge.RequestOptions
-
-
client.confirmationToken.retrieve(confirmationToken, { ...params }) -> Stripe.ConfirmationToken
-
-
-
Retrieves an existing ConfirmationToken object
-
-
-
await client.confirmationToken.retrieve("confirmation_token");
-
-
-
confirmationToken:
string
-
request:
Stripe.ConfirmationTokenRetrieveRequest
-
requestOptions:
ConfirmationToken.RequestOptions
-
-
client.confirmationToken.create({ ...params }) -> Stripe.ConfirmationToken
-
-
-
Creates a test mode Confirmation Token server side for your integration tests.
-
-
-
await client.confirmationToken.create();
-
-
-
request:
Stripe.ConfirmationTokenCreateRequest
-
requestOptions:
ConfirmationToken.RequestOptions
-
-
client.countrySpec.list({ ...params }) -> Stripe.CountrySpecListResponse
-
-
-
Lists all Country Spec objects available in the API.
-
-
-
await client.countrySpec.list();
-
-
-
request:
Stripe.CountrySpecListRequest
-
requestOptions:
CountrySpec.RequestOptions
-
-
client.countrySpec.retrieve(country, { ...params }) -> Stripe.CountrySpec
-
-
-
Returns a Country Spec for a given Country code.
-
-
-
await client.countrySpec.retrieve("country");
-
-
-
country:
string
-
request:
Stripe.CountrySpecRetrieveRequest
-
requestOptions:
CountrySpec.RequestOptions
-
-
client.coupon.list({ ...params }) -> Stripe.CouponListResponse
-
-
-
Returns a list of your coupons.
-
-
-
await client.coupon.list();
-
-
-
request:
Stripe.CouponListRequest
-
requestOptions:
Coupon.RequestOptions
-
-
client.coupon.create({ ...params }) -> Stripe.Coupon
-
-
-
You can create coupons easily via the coupon management page of the Stripe dashboard. Coupon creation is also accessible via the API if you need to create coupons on the fly.
A coupon has either a
percent_offor anamount_offandcurrency. If you set anamount_off, that amount will be subtracted from any invoice’s subtotal. For example, an invoice with a subtotal of 100 will have a final total of 0 if a coupon with anamount_offof 200 is applied to it and an invoice with a subtotal of 300 will have a final total of 100 if a coupon with anamount_offof 200 is applied to it.
-
-
-
await client.coupon.create();
-
-
-
request:
Stripe.CouponCreateRequest
-
requestOptions:
Coupon.RequestOptions
-
-
client.coupon.retrieve(coupon, { ...params }) -> Stripe.Coupon
-
-
-
Retrieves the coupon with the given ID.
-
-
-
await client.coupon.retrieve("coupon");
-
-
-
coupon:
string
-
request:
Stripe.CouponRetrieveRequest
-
requestOptions:
Coupon.RequestOptions
-
-
client.coupon.update(coupon, { ...params }) -> Stripe.Coupon
-
-
-
Updates the metadata of a coupon. Other coupon details (currency, duration, amount_off) are, by design, not editable.
-
-
-
await client.coupon.update("coupon");
-
-
-
coupon:
string
-
request:
Stripe.CouponUpdateRequest
-
requestOptions:
Coupon.RequestOptions
-
-
client.coupon.delete(coupon, { ...params }) -> Stripe.DeletedCoupon
-
-
-
You can delete coupons via the coupon management page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can’t redeem the coupon. You can also delete coupons via the API.
-
-
-
await client.coupon.delete("coupon");
-
-
-
coupon:
string
-
request:
Stripe.CouponDeleteRequest
-
requestOptions:
Coupon.RequestOptions
-
-
client.creditNote.list({ ...params }) -> Stripe.CreditNoteListResponse
-
-
-
Returns a list of credit notes.
-
-
-
await client.creditNote.list();
-
-
-
request:
Stripe.CreditNoteListRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNote.create({ ...params }) -> Stripe.CreditNote
-
-
-
Issue a credit note to adjust the amount of a finalized invoice. For a
status=openinvoice, a credit note reduces itsamount_due. For astatus=paidinvoice, a credit note does not affect itsamount_due. Instead, it can result in any combination of the following:- Refund: create a new refund (using
refund_amount) or link an existing refund (usingrefund). - Customer balance credit: credit the customer’s balance (using
credit_amount) which will be automatically applied to their next invoice when it’s finalized. - Outside of Stripe credit: record the amount that is or will be credited outside of Stripe (using
out_of_band_amount).
For post-payment credit notes the sum of the refund, credit and outside of Stripe amounts must equal the credit note total.
You may issue multiple credit notes for an invoice. Each credit note will increment the invoice’s
pre_payment_credit_notes_amountorpost_payment_credit_notes_amountdepending on itsstatusat the time of credit note creation. - Refund: create a new refund (using
-
-
-
await client.creditNote.create({ invoice: "invoice", });
-
-
-
request:
Stripe.CreditNoteCreateRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNote.preview({ ...params }) -> Stripe.CreditNote
-
-
-
Get a preview of a credit note without creating it.
-
-
-
await client.creditNote.preview({ invoice: "invoice", });
-
-
-
request:
Stripe.CreditNotePreviewRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNote.previewLines({ ...params }) -> Stripe.CreditNotePreviewLinesResponse
-
-
-
When retrieving a credit note preview, you’ll get a lines property containing the first handful of those items. This URL you can retrieve the full (paginated) list of line items.
-
-
-
await client.creditNote.previewLines({ invoice: "invoice", });
-
-
-
request:
Stripe.CreditNotePreviewLinesRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNote.retrieve(id, { ...params }) -> Stripe.CreditNote
-
-
-
Retrieves the credit note object with the given identifier.
-
-
-
await client.creditNote.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.CreditNoteRetrieveRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNote.update(id, { ...params }) -> Stripe.CreditNote
-
-
-
Updates an existing credit note.
-
-
-
await client.creditNote.update("id");
-
-
-
id:
string
-
request:
Stripe.CreditNoteUpdateRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNote.voidCreditNote(id, { ...params }) -> Stripe.CreditNote
-
-
-
Marks a credit note as void. Learn more about voiding credit notes.
-
-
-
await client.creditNote.voidCreditNote("id");
-
-
-
id:
string
-
request:
Stripe.CreditNoteVoidCreditNoteRequest
-
requestOptions:
CreditNote.RequestOptions
-
-
client.creditNoteLineItem.list(creditNote, { ...params }) -> Stripe.CreditNoteLineItemListResponse
-
-
-
When retrieving a credit note, you’ll get a lines property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
-
-
-
await client.creditNoteLineItem.list("credit_note");
-
-
-
creditNote:
string
-
request:
Stripe.CreditNoteLineItemListRequest
-
requestOptions:
CreditNoteLineItem.RequestOptions
-
-
client.customerSession.create({ ...params }) -> Stripe.CustomerSession
-
-
-
Creates a Customer Session object that includes a single-use client secret that you can use on your front-end to grant client-side API access for certain customer resources.
-
-
-
await client.customerSession.create({ components: {}, customer: "customer", });
-
-
-
request:
Stripe.CustomerSessionCreateRequest
-
requestOptions:
CustomerSession.RequestOptions
-
-
client.customer.list({ ...params }) -> Stripe.CustomerListResponse
-
-
-
Returns a list of your customers. The customers are returned sorted by creation date, with the most recent customers appearing first.
-
-
-
await client.customer.list();
-
-
-
request:
Stripe.CustomerListRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.create({ ...params }) -> Stripe.Customer
-
-
-
Creates a new customer object.
-
-
-
await client.customer.create();
-
-
-
request:
Stripe.CustomerCreateRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.search({ ...params }) -> Stripe.CustomerSearchResponse
-
-
-
Search for customers you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.customer.search({ query: "query", });
-
-
-
request:
Stripe.CustomerSearchRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.retrieve(customer, { ...params }) -> Stripe.CustomerRetrieveResponse
-
-
-
Retrieves a Customer object.
-
-
-
await client.customer.retrieve("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerRetrieveRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.update(customer, { ...params }) -> Stripe.Customer
-
-
-
Updates the specified customer by setting the values of the parameters passed. Any parameters not provided will be left unchanged. For example, if you pass the source parameter, that becomes the customer’s active source (e.g., a card) to be used for all charges in the future. When you update a customer to a new valid card source by passing the source parameter: for each of the customer’s current subscriptions, if the subscription bills automatically and is in the
past_duestate, then the latest open invoice for the subscription with automatic collection enabled will be retried. This retry will not count as an automatic retry, and will not affect the next regularly scheduled payment for the invoice. Changing the default_source for a customer will not trigger this behavior.This request accepts mostly the same arguments as the customer creation call.
-
-
-
await client.customer.update("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerUpdateRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.delete(customer, { ...params }) -> Stripe.DeletedCustomer
-
-
-
Permanently deletes a customer. It cannot be undone. Also immediately cancels any active subscriptions on the customer.
-
-
-
await client.customer.delete("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerDeleteRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.deleteDiscount(customer, { ...params }) -> Stripe.DeletedDiscount
-
-
-
Removes the currently applied discount on a customer.
-
-
-
await client.customer.deleteDiscount("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerDeleteDiscountRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.createFundingInstructions(customer, { ...params }) -> Stripe.FundingInstructions
-
-
-
Retrieve funding instructions for a customer cash balance. If funding instructions do not yet exist for the customer, new funding instructions will be created. If funding instructions have already been created for a given customer, the same funding instructions will be retrieved. In other words, we will return the same funding instructions each time.
-
-
-
await client.customer.createFundingInstructions("customer", { bank_transfer: { type: "eu_bank_transfer", }, currency: "currency", });
-
-
-
customer:
string
-
request:
Stripe.CustomerCreateFundingInstructionsRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.listPaymentMethods(customer, { ...params }) -> Stripe.CustomerListPaymentMethodsResponse
-
-
-
Returns a list of PaymentMethods for a given Customer
-
-
-
await client.customer.listPaymentMethods("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerListPaymentMethodsRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.retrievePaymentMethod(customer, paymentMethod, { ...params }) -> Stripe.PaymentMethod
-
-
-
Retrieves a PaymentMethod object for a given Customer.
-
-
-
await client.customer.retrievePaymentMethod("customer", "payment_method");
-
-
-
customer:
string
-
paymentMethod:
string
-
request:
Stripe.CustomerRetrievePaymentMethodRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customer.fundCashBalance(customer, { ...params }) -> Stripe.CustomerCashBalanceTransaction
-
-
-
Create an incoming testmode bank transfer
-
-
-
await client.customer.fundCashBalance("customer", { amount: 1, currency: "currency", });
-
-
-
customer:
string
-
request:
Stripe.CustomerFundCashBalanceRequest
-
requestOptions:
Customer.RequestOptions
-
-
client.customerBalanceTransaction.list(customer, { ...params }) -> Stripe.CustomerBalanceTransactionListResponse
-
-
-
Returns a list of transactions that updated the customer’s balances.
-
-
-
await client.customerBalanceTransaction.list("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerBalanceTransactionListRequest
-
requestOptions:
CustomerBalanceTransaction.RequestOptions
-
-
client.customerBalanceTransaction.create(customer, { ...params }) -> Stripe.CustomerBalanceTransaction
-
-
-
Creates an immutable transaction that updates the customer’s credit balance.
-
-
-
await client.customerBalanceTransaction.create("customer", { amount: 1, currency: "currency", });
-
-
-
customer:
string
-
request:
Stripe.CustomerBalanceTransactionCreateRequest
-
requestOptions:
CustomerBalanceTransaction.RequestOptions
-
-
client.customerBalanceTransaction.retrieve(customer, transaction, { ...params }) -> Stripe.CustomerBalanceTransaction
-
-
-
Retrieves a specific customer balance transaction that updated the customer’s balances.
-
-
-
await client.customerBalanceTransaction.retrieve("customer", "transaction");
-
-
-
customer:
string
-
transaction:
string
-
request:
Stripe.CustomerBalanceTransactionRetrieveRequest
-
requestOptions:
CustomerBalanceTransaction.RequestOptions
-
-
client.customerBalanceTransaction.update(customer, transaction, { ...params }) -> Stripe.CustomerBalanceTransaction
-
-
-
Most credit balance transaction fields are immutable, but you may update its
descriptionandmetadata.
-
-
-
await client.customerBalanceTransaction.update("customer", "transaction");
-
-
-
customer:
string
-
transaction:
string
-
request:
Stripe.CustomerBalanceTransactionUpdateRequest
-
requestOptions:
CustomerBalanceTransaction.RequestOptions
-
-
client.cashBalance.retrieve(customer, { ...params }) -> Stripe.CashBalance
-
-
-
Retrieves a customer’s cash balance.
-
-
-
await client.cashBalance.retrieve("customer");
-
-
-
customer:
string
-
request:
Stripe.CashBalanceRetrieveRequest
-
requestOptions:
CashBalance.RequestOptions
-
-
client.cashBalance.update(customer, { ...params }) -> Stripe.CashBalance
-
-
-
Changes the settings on a customer’s cash balance.
-
-
-
await client.cashBalance.update("customer");
-
-
-
customer:
string
-
request:
Stripe.CashBalanceUpdateRequest
-
requestOptions:
CashBalance.RequestOptions
-
-
client.customerCashBalanceTransaction.list(customer, { ...params }) -> Stripe.CustomerCashBalanceTransactionListResponse
-
-
-
Returns a list of transactions that modified the customer’s cash balance.
-
-
-
await client.customerCashBalanceTransaction.list("customer");
-
-
-
customer:
string
-
request:
Stripe.CustomerCashBalanceTransactionListRequest
-
requestOptions:
CustomerCashBalanceTransaction.RequestOptions
-
-
client.customerCashBalanceTransaction.retrieve(customer, transaction, { ...params }) -> Stripe.CustomerCashBalanceTransaction
-
-
-
Retrieves a specific cash balance transaction, which updated the customer’s cash balance.
-
-
-
await client.customerCashBalanceTransaction.retrieve("customer", "transaction");
-
-
-
customer:
string
-
transaction:
string
-
request:
Stripe.CustomerCashBalanceTransactionRetrieveRequest
-
requestOptions:
CustomerCashBalanceTransaction.RequestOptions
-
-
client.paymentSource.list(customer, { ...params }) -> Stripe.PaymentSourceListResponse
-
-
-
List sources for a specified customer.
-
-
-
await client.paymentSource.list("customer");
-
-
-
customer:
string
-
request:
Stripe.PaymentSourceListRequest
-
requestOptions:
PaymentSource.RequestOptions
-
-
client.paymentSource.create(customer, { ...params }) -> Stripe.PaymentSource
-
-
-
When you create a new credit card, you must specify a customer or recipient on which to create it.
If the card’s owner has no default card, then the new card will become the default. However, if the owner already has a default, then it will not change. To change the default, you should update the customer to have a new
default_source.
-
-
-
await client.paymentSource.create("customer", { source: "source", });
-
-
-
customer:
string
-
request:
Stripe.PaymentSourceCreateRequest
-
requestOptions:
PaymentSource.RequestOptions
-
-
client.paymentSource.retrieve(customer, id, { ...params }) -> Stripe.PaymentSource
-
-
-
Retrieve a specified source for a given customer.
-
-
-
await client.paymentSource.retrieve("customer", "id");
-
-
-
customer:
string
-
id:
string
-
request:
Stripe.PaymentSourceRetrieveRequest
-
requestOptions:
PaymentSource.RequestOptions
-
-
client.source.detach(customer, id, { ...params }) -> Stripe.SourceDetachResponse
-
-
-
Delete a specified source for a given customer.
-
-
-
await client.source.detach("customer", "id");
-
-
-
customer:
string
-
id:
string
-
request:
Stripe.SourceDetachRequest
-
requestOptions:
Source.RequestOptions
-
-
client.source.create({ ...params }) -> Stripe.Source
-
-
-
Creates a new source object.
-
-
-
await client.source.create();
-
-
-
request:
Stripe.SourceCreateRequest
-
requestOptions:
Source.RequestOptions
-
-
client.source.retrieve(source, { ...params }) -> Stripe.Source
-
-
-
Retrieves an existing source object. Supply the unique source ID from a source creation request and Stripe will return the corresponding up-to-date source object information.
-
-
-
await client.source.retrieve("source");
-
-
-
source:
string
-
request:
Stripe.SourceRetrieveRequest
-
requestOptions:
Source.RequestOptions
-
-
client.source.update(source, { ...params }) -> Stripe.Source
-
-
-
Updates the specified source by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
This request accepts the
metadataandowneras arguments. It is also possible to update type specific information for selected payment methods. Please refer to our payment method guides for more detail.
-
-
-
await client.source.update("source");
-
-
-
source:
string
-
request:
Stripe.SourceUpdateRequest
-
requestOptions:
Source.RequestOptions
-
-
client.source.sourceTransactions(source, { ...params }) -> Stripe.SourceSourceTransactionsResponse
-
-
-
List source transactions for a given source.
-
-
-
await client.source.sourceTransactions("source");
-
-
-
source:
string
-
request:
Stripe.SourceSourceTransactionsRequest
-
requestOptions:
Source.RequestOptions
-
-
client.source.verify(source, { ...params }) -> Stripe.Source
-
-
-
Verify a given source.
-
-
-
await client.source.verify("source", { values: ["values"], });
-
-
-
source:
string
-
request:
Stripe.SourceVerifyRequest
-
requestOptions:
Source.RequestOptions
-
-
client.bankAccount.verify(customer, id, { ...params }) -> Stripe.BankAccount
-
-
-
Verify a specified bank account for a given customer.
-
-
-
await client.bankAccount.verify("customer", "id");
-
-
-
customer:
string
-
id:
string
-
request:
Stripe.BankAccountVerifyRequest
-
requestOptions:
BankAccount.RequestOptions
-
-
client.taxId.list(customer, { ...params }) -> Stripe.TaxIdListResponse
-
-
-
Returns a list of tax IDs for a customer.
-
-
-
await client.taxId.list("customer");
-
-
-
customer:
string
-
request:
Stripe.TaxIdListRequest
-
requestOptions:
TaxId.RequestOptions
-
-
client.taxId.create(customer, { ...params }) -> Stripe.TaxId
-
-
-
Creates a new
tax_idobject for a customer.
-
-
-
await client.taxId.create("customer", { type: "ad_nrt", value: "value", });
-
-
-
customer:
string
-
request:
Stripe.TaxIdCreateRequest
-
requestOptions:
TaxId.RequestOptions
-
-
client.taxId.retrieve(customer, id, { ...params }) -> Stripe.TaxId
-
-
-
Retrieves the
tax_idobject with the given identifier.
-
-
-
await client.taxId.retrieve("customer", "id");
-
-
-
customer:
string
-
id:
string
-
request:
Stripe.TaxIdRetrieveRequest
-
requestOptions:
TaxId.RequestOptions
-
-
client.taxId.delete(customer, id, { ...params }) -> Stripe.DeletedTaxId
-
-
-
Deletes an existing
tax_idobject.
-
-
-
await client.taxId.delete("customer", "id");
-
-
-
customer:
string
-
id:
string
-
request:
Stripe.TaxIdDeleteRequest
-
requestOptions:
TaxId.RequestOptions
-
-
client.dispute.list({ ...params }) -> Stripe.DisputeListResponse
-
-
-
Returns a list of your disputes.
-
-
-
await client.dispute.list();
-
-
-
request:
Stripe.DisputeListRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.dispute.retrieve(dispute, { ...params }) -> Stripe.Dispute
-
-
-
Retrieves the dispute with the given ID.
-
-
-
await client.dispute.retrieve("dispute");
-
-
-
dispute:
string
-
request:
Stripe.DisputeRetrieveRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.dispute.update(dispute, { ...params }) -> Stripe.Dispute
-
-
-
When you get a dispute, contacting your customer is always the best first step. If that doesn’t work, you can submit evidence to help us resolve the dispute in your favor. You can do this in your dashboard, but if you prefer, you can use the API to submit evidence programmatically.
Depending on your dispute type, different evidence fields will give you a better chance of winning your dispute. To figure out which evidence fields to provide, see our guide to dispute types.
-
-
-
await client.dispute.update("dispute");
-
-
-
dispute:
string
-
request:
Stripe.DisputeUpdateRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.dispute.close(dispute, { ...params }) -> Stripe.Dispute
-
-
-
Closing the dispute for a charge indicates that you do not have any evidence to submit and are essentially dismissing the dispute, acknowledging it as lost.
The status of the dispute will change from
needs_responsetolost. Closing a dispute is irreversible.
-
-
-
await client.dispute.close("dispute");
-
-
-
dispute:
string
-
request:
Stripe.DisputeCloseRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.ephemeralKey.create({ ...params }) -> Stripe.EphemeralKey
-
-
-
Creates a short-lived API key for a given resource.
-
-
-
await client.ephemeralKey.create();
-
-
-
request:
Stripe.EphemeralKeyCreateRequest
-
requestOptions:
EphemeralKey.RequestOptions
-
-
client.ephemeralKey.delete(key, { ...params }) -> Stripe.EphemeralKey
-
-
-
Invalidates a short-lived API key for a given resource.
-
-
-
await client.ephemeralKey.delete("key");
-
-
-
key:
string
-
request:
Stripe.EphemeralKeyDeleteRequest
-
requestOptions:
EphemeralKey.RequestOptions
-
-
client.event.list({ ...params }) -> Stripe.EventListResponse
-
-
-
List events, going back up to 30 days. Each event data is rendered according to Stripe API version at its creation time, specified in event object
api_versionattribute (not according to your current Stripe API version orStripe-Versionheader).
-
-
-
await client.event.list();
-
-
-
request:
Stripe.EventListRequest
-
requestOptions:
Event.RequestOptions
-
-
client.event.retrieve(id, { ...params }) -> Stripe.Event
-
-
-
Retrieves the details of an event if it was created in the last 30 days. Supply the unique identifier of the event, which you might have received in a webhook.
-
-
-
await client.event.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.EventRetrieveRequest
-
requestOptions:
Event.RequestOptions
-
-
client.exchangeRate.list({ ...params }) -> Stripe.ExchangeRateListResponse
-
-
-
Returns a list of objects that contain the rates at which foreign currencies are converted to one another. Only shows the currencies for which Stripe supports.
-
-
-
await client.exchangeRate.list();
-
-
-
request:
Stripe.ExchangeRateListRequest
-
requestOptions:
ExchangeRate.RequestOptions
-
-
client.exchangeRate.retrieve(rateId, { ...params }) -> Stripe.ExchangeRate
-
-
-
Retrieves the exchange rates from the given currency to every supported currency.
-
-
-
await client.exchangeRate.retrieve("rate_id");
-
-
-
rateId:
string
-
request:
Stripe.ExchangeRateRetrieveRequest
-
requestOptions:
ExchangeRate.RequestOptions
-
-
client.fileLink.list({ ...params }) -> Stripe.FileLinkListResponse
-
-
-
Returns a list of file links.
-
-
-
await client.fileLink.list();
-
-
-
request:
Stripe.FileLinkListRequest
-
requestOptions:
FileLink.RequestOptions
-
-
client.fileLink.create({ ...params }) -> Stripe.FileLink
-
-
-
Creates a new file link object.
-
-
-
await client.fileLink.create({ file: "file", });
-
-
-
request:
Stripe.FileLinkCreateRequest
-
requestOptions:
FileLink.RequestOptions
-
-
client.fileLink.retrieve(link, { ...params }) -> Stripe.FileLink
-
-
-
Retrieves the file link with the given ID.
-
-
-
await client.fileLink.retrieve("link");
-
-
-
link:
string
-
request:
Stripe.FileLinkRetrieveRequest
-
requestOptions:
FileLink.RequestOptions
-
-
client.fileLink.update(link, { ...params }) -> Stripe.FileLink
-
-
-
Updates an existing file link object. Expired links can no longer be updated.
-
-
-
await client.fileLink.update("link");
-
-
-
link:
string
-
request:
Stripe.FileLinkUpdateRequest
-
requestOptions:
FileLink.RequestOptions
-
-
client.file.list({ ...params }) -> Stripe.FileListResponse
-
-
-
Returns a list of the files that your account has access to. Stripe sorts and returns the files by their creation dates, placing the most recently created files at the top.
-
-
-
await client.file.list();
-
-
-
request:
Stripe.FileListRequest
-
requestOptions:
File_.RequestOptions
-
-
client.file.retrieve(file, { ...params }) -> Stripe.File_
-
-
-
Retrieves the details of an existing file object. After you supply a unique file ID, Stripe returns the corresponding file object. Learn how to access file contents.
-
-
-
await client.file.retrieve("file");
-
-
-
file:
string
-
request:
Stripe.FileRetrieveRequest
-
requestOptions:
File_.RequestOptions
-
-
client.invoiceRenderingTemplate.list({ ...params }) -> Stripe.InvoiceRenderingTemplateListResponse
-
-
-
List all templates, ordered by creation date, with the most recently created template appearing first.
-
-
-
await client.invoiceRenderingTemplate.list();
-
-
-
request:
Stripe.InvoiceRenderingTemplateListRequest
-
requestOptions:
InvoiceRenderingTemplate.RequestOptions
-
-
client.invoiceRenderingTemplate.retrieve(template, { ...params }) -> Stripe.InvoiceRenderingTemplate
-
-
-
Retrieves an invoice rendering template with the given ID. It by default returns the latest version of the template. Optionally, specify a version to see previous versions.
-
-
-
await client.invoiceRenderingTemplate.retrieve("template");
-
-
-
template:
string
-
request:
Stripe.InvoiceRenderingTemplateRetrieveRequest
-
requestOptions:
InvoiceRenderingTemplate.RequestOptions
-
-
client.invoiceRenderingTemplate.archive(template, { ...params }) -> Stripe.InvoiceRenderingTemplate
-
-
-
Updates the status of an invoice rendering template to ‘archived’ so no new Stripe objects (customers, invoices, etc.) can reference it. The template can also no longer be updated. However, if the template is already set on a Stripe object, it will continue to be applied on invoices generated by it.
-
-
-
await client.invoiceRenderingTemplate.archive("template");
-
-
-
template:
string
-
request:
Stripe.InvoiceRenderingTemplateArchiveRequest
-
requestOptions:
InvoiceRenderingTemplate.RequestOptions
-
-
client.invoiceRenderingTemplate.unarchive(template, { ...params }) -> Stripe.InvoiceRenderingTemplate
-
-
-
Unarchive an invoice rendering template so it can be used on new Stripe objects again.
-
-
-
await client.invoiceRenderingTemplate.unarchive("template");
-
-
-
template:
string
-
request:
Stripe.InvoiceRenderingTemplateUnarchiveRequest
-
requestOptions:
InvoiceRenderingTemplate.RequestOptions
-
-
client.invoiceitem.list({ ...params }) -> Stripe.InvoiceitemListResponse
-
-
-
Returns a list of your invoice items. Invoice items are returned sorted by creation date, with the most recently created invoice items appearing first.
-
-
-
await client.invoiceitem.list();
-
-
-
request:
Stripe.InvoiceitemListRequest
-
requestOptions:
Invoiceitem.RequestOptions
-
-
client.invoiceitem.create({ ...params }) -> Stripe.Invoiceitem
-
-
-
Creates an item to be added to a draft invoice (up to 250 items per invoice). If no invoice is specified, the item will be on the next invoice created for the customer specified.
-
-
-
await client.invoiceitem.create({ customer: "customer", });
-
-
-
request:
Stripe.InvoiceitemCreateRequest
-
requestOptions:
Invoiceitem.RequestOptions
-
-
client.invoiceitem.retrieve(invoiceitem, { ...params }) -> Stripe.Invoiceitem
-
-
-
Retrieves the invoice item with the given ID.
-
-
-
await client.invoiceitem.retrieve("invoiceitem");
-
-
-
invoiceitem:
string
-
request:
Stripe.InvoiceitemRetrieveRequest
-
requestOptions:
Invoiceitem.RequestOptions
-
-
client.invoiceitem.update(invoiceitem, { ...params }) -> Stripe.Invoiceitem
-
-
-
Updates the amount or description of an invoice item on an upcoming invoice. Updating an invoice item is only possible before the invoice it’s attached to is closed.
-
-
-
await client.invoiceitem.update("invoiceitem");
-
-
-
invoiceitem:
string
-
request:
Stripe.InvoiceitemUpdateRequest
-
requestOptions:
Invoiceitem.RequestOptions
-
-
client.invoiceitem.delete(invoiceitem, { ...params }) -> Stripe.DeletedInvoiceitem
-
-
-
Deletes an invoice item, removing it from an invoice. Deleting invoice items is only possible when they’re not attached to invoices, or if it’s attached to a draft invoice.
-
-
-
await client.invoiceitem.delete("invoiceitem");
-
-
-
invoiceitem:
string
-
request:
Stripe.InvoiceitemDeleteRequest
-
requestOptions:
Invoiceitem.RequestOptions
-
-
client.invoice.list({ ...params }) -> Stripe.InvoiceListResponse
-
-
-
You can list all invoices, or list the invoices for a specific customer. The invoices are returned sorted by creation date, with the most recently created invoices appearing first.
-
-
-
await client.invoice.list();
-
-
-
request:
Stripe.InvoiceListRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.create({ ...params }) -> Stripe.Invoice
client.invoice.createPreview({ ...params }) -> Stripe.Invoice
-
-
-
At any time, you can preview the upcoming invoice for a customer. This will show you all the charges that are pending, including subscription renewal charges, invoice item charges, etc. It will also show you any discounts that are applicable to the invoice.
Note that when you are viewing an upcoming invoice, you are simply viewing a preview – the invoice has not yet been created. As such, the upcoming invoice will not show up in invoice listing calls, and you cannot use the API to pay or edit the invoice. If you want to change the amount that your customer will be billed, you can add, remove, or update pending invoice items, or update the customer’s discount.
You can preview the effects of updating a subscription, including a preview of what proration will take place. To ensure that the actual proration is calculated exactly the same as the previewed proration, you should pass the
subscription_details.proration_dateparameter when doing the actual subscription update. The recommended way to get only the prorations being previewed is to consider only proration line items whereperiod[start]is equal to thesubscription_details.proration_datevalue passed in the request.Note: Currency conversion calculations use the latest exchange rates. Exchange rates may vary between the time of the preview and the time of the actual invoice creation. Learn more
-
-
-
await client.invoice.createPreview();
-
-
-
request:
Stripe.InvoiceCreatePreviewRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.search({ ...params }) -> Stripe.InvoiceSearchResponse
-
-
-
Search for invoices you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.invoice.search({ query: "query", });
-
-
-
request:
Stripe.InvoiceSearchRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.upcoming({ ...params }) -> Stripe.Invoice
-
-
-
At any time, you can preview the upcoming invoice for a customer. This will show you all the charges that are pending, including subscription renewal charges, invoice item charges, etc. It will also show you any discounts that are applicable to the invoice.
Note that when you are viewing an upcoming invoice, you are simply viewing a preview – the invoice has not yet been created. As such, the upcoming invoice will not show up in invoice listing calls, and you cannot use the API to pay or edit the invoice. If you want to change the amount that your customer will be billed, you can add, remove, or update pending invoice items, or update the customer’s discount.
You can preview the effects of updating a subscription, including a preview of what proration will take place. To ensure that the actual proration is calculated exactly the same as the previewed proration, you should pass the
subscription_details.proration_dateparameter when doing the actual subscription update. The recommended way to get only the prorations being previewed is to consider only proration line items whereperiod[start]is equal to thesubscription_details.proration_datevalue passed in the request.Note: Currency conversion calculations use the latest exchange rates. Exchange rates may vary between the time of the preview and the time of the actual invoice creation. Learn more
-
-
-
await client.invoice.upcoming();
-
-
-
request:
Stripe.InvoiceUpcomingRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.upcomingLines({ ...params }) -> Stripe.InvoiceUpcomingLinesResponse
-
-
-
When retrieving an upcoming invoice, you’ll get a lines property containing the total count of line items and the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
-
-
-
await client.invoice.upcomingLines();
-
-
-
request:
Stripe.InvoiceUpcomingLinesRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.retrieve(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Retrieves the invoice with the given ID.
-
-
-
await client.invoice.retrieve("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceRetrieveRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.update(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Draft invoices are fully editable. Once an invoice is finalized, monetary values, as well as
collection_method, become uneditable.If you would like to stop the Stripe Billing engine from automatically finalizing, reattempting payments on, sending reminders for, or automatically reconciling invoices, pass
auto_advance=false.
-
-
-
await client.invoice.update("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceUpdateRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.delete(invoice, { ...params }) -> Stripe.DeletedInvoice
-
-
-
Permanently deletes a one-off invoice draft. This cannot be undone. Attempts to delete invoices that are no longer in a draft state will fail; once an invoice has been finalized or if an invoice is for a subscription, it must be voided.
-
-
-
await client.invoice.delete("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceDeleteRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.addLines(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Adds multiple line items to an invoice. This is only possible when an invoice is still a draft.
-
-
-
await client.invoice.addLines("invoice", { lines: [{}], });
-
-
-
invoice:
string
-
request:
Stripe.InvoiceAddLinesRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.finalizeInvoice(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Stripe automatically finalizes drafts before sending and attempting payment on invoices. However, if you’d like to finalize a draft invoice manually, you can do so using this method.
-
-
-
await client.invoice.finalizeInvoice("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceFinalizeInvoiceRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.markUncollectible(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Marking an invoice as uncollectible is useful for keeping track of bad debts that can be written off for accounting purposes.
-
-
-
await client.invoice.markUncollectible("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceMarkUncollectibleRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.pay(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Stripe automatically creates and then attempts to collect payment on invoices for customers on subscriptions according to your subscriptions settings. However, if you’d like to attempt payment on an invoice out of the normal collection schedule or for some other reason, you can do so.
-
-
-
await client.invoice.pay("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoicePayRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.removeLines(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Removes multiple line items from an invoice. This is only possible when an invoice is still a draft.
-
-
-
await client.invoice.removeLines("invoice", { lines: [ { behavior: "delete", id: "id", }, ], });
-
-
-
invoice:
string
-
request:
Stripe.InvoiceRemoveLinesRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.sendInvoice(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Stripe will automatically send invoices to customers according to your subscriptions settings. However, if you’d like to manually send an invoice to your customer out of the normal schedule, you can do so. When sending invoices that have already been paid, there will be no reference to the payment in the email.
Requests made in test-mode result in no emails being sent, despite sending an
invoice.sentevent.
-
-
-
await client.invoice.sendInvoice("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceSendInvoiceRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.updateLines(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Updates multiple line items on an invoice. This is only possible when an invoice is still a draft.
-
-
-
await client.invoice.updateLines("invoice", { lines: [ { id: "id", }, ], });
-
-
-
invoice:
string
-
request:
Stripe.InvoiceUpdateLinesRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.invoice.voidInvoice(invoice, { ...params }) -> Stripe.Invoice
-
-
-
Mark a finalized invoice as void. This cannot be undone. Voiding an invoice is similar to deletion, however it only applies to finalized invoices and maintains a papertrail where the invoice can still be found.
Consult with local regulations to determine whether and how an invoice might be amended, canceled, or voided in the jurisdiction you’re doing business in. You might need to issue another invoice or credit note instead. Stripe recommends that you consult with your legal counsel for advice specific to your business.
-
-
-
await client.invoice.voidInvoice("invoice");
-
-
-
invoice:
string
-
request:
Stripe.InvoiceVoidInvoiceRequest
-
requestOptions:
Invoice.RequestOptions
-
-
client.lineItem.list(invoice, { ...params }) -> Stripe.LineItemListResponse
-
-
-
When retrieving an invoice, you’ll get a lines property containing the total count of line items and the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
-
-
-
await client.lineItem.list("invoice");
-
-
-
invoice:
string
-
request:
Stripe.LineItemListRequest
-
requestOptions:
LineItem.RequestOptions
-
-
client.lineItem.update(invoice, lineItemId, { ...params }) -> Stripe.LineItem
-
-
-
Updates an invoice’s line item. Some fields, such as
tax_amounts, only live on the invoice line item, so they can only be updated through this endpoint. Other fields, such asamount, live on both the invoice item and the invoice line item, so updates on this endpoint will propagate to the invoice item as well. Updating an invoice’s line item is only possible before the invoice is finalized.
-
-
-
await client.lineItem.update("invoice", "line_item_id");
-
-
-
invoice:
string— Invoice ID of line item
-
lineItemId:
string— Invoice line item ID
-
request:
Stripe.LineItemUpdateRequest
-
requestOptions:
LineItem.RequestOptions
-
-
client.mandate.retrieve(mandate, { ...params }) -> Stripe.Mandate
-
-
-
Retrieves a Mandate object.
-
-
-
await client.mandate.retrieve("mandate");
-
-
-
mandate:
string
-
request:
Stripe.MandateRetrieveRequest
-
requestOptions:
Mandate.RequestOptions
-
-
client.paymentIntent.list({ ...params }) -> Stripe.PaymentIntentListResponse
-
-
-
Returns a list of PaymentIntents.
-
-
-
await client.paymentIntent.list();
-
-
-
request:
Stripe.PaymentIntentListRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.create({ ...params }) -> Stripe.PaymentIntent
-
-
-
Creates a PaymentIntent object.
After the PaymentIntent is created, attach a payment method and confirm to continue the payment. Learn more about the available payment flows with the Payment Intents API.
When you use
confirm=trueduring creation, it’s equivalent to creating and confirming the PaymentIntent in the same call. You can use any parameters available in the confirm API when you supplyconfirm=true.
-
-
-
await client.paymentIntent.create({ amount: 1, currency: "currency", });
-
-
-
request:
Stripe.PaymentIntentCreateRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.search({ ...params }) -> Stripe.PaymentIntentSearchResponse
-
-
-
Search for PaymentIntents you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.paymentIntent.search({ query: "query", });
-
-
-
request:
Stripe.PaymentIntentSearchRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.retrieve(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Retrieves the details of a PaymentIntent that has previously been created.
You can retrieve a PaymentIntent client-side using a publishable key when the
client_secretis in the query string.If you retrieve a PaymentIntent with a publishable key, it only returns a subset of properties. Refer to the payment intent object reference for more details.
-
-
-
await client.paymentIntent.retrieve("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentRetrieveRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.update(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Updates properties on a PaymentIntent object without confirming.
Depending on which properties you update, you might need to confirm the PaymentIntent again. For example, updating the
payment_methodalways requires you to confirm the PaymentIntent again. If you prefer to update and confirm at the same time, we recommend updating properties through the confirm API instead.
-
-
-
await client.paymentIntent.update("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentUpdateRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.applyCustomerBalance(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Manually reconcile the remaining amount for a
customer_balancePaymentIntent.
-
-
-
await client.paymentIntent.applyCustomerBalance("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentApplyCustomerBalanceRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.cancel(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
You can cancel a PaymentIntent object when it’s in one of these statuses:
requires_payment_method,requires_capture,requires_confirmation,requires_actionor, in rare cases,processing.After it’s canceled, no additional charges are made by the PaymentIntent and any operations on the PaymentIntent fail with an error. For PaymentIntents with a
statusofrequires_capture, the remainingamount_capturableis automatically refunded.You can’t cancel the PaymentIntent for a Checkout Session. Expire the Checkout Session instead.
-
-
-
await client.paymentIntent.cancel("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentCancelRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.capture(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Capture the funds of an existing uncaptured PaymentIntent when its status is
requires_capture.Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their creation.
Learn more about separate authorization and capture.
-
-
-
await client.paymentIntent.capture("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentCaptureRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.confirm(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Confirm that your customer intends to pay with current or provided payment method. Upon confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment method requires additional authentication steps, the PaymentIntent will transition to the
requires_actionstatus and suggest additional actions vianext_action. If payment fails, the PaymentIntent transitions to therequires_payment_methodstatus or thecanceledstatus if the confirmation limit is reached. If payment succeeds, the PaymentIntent will transition to thesucceededstatus (orrequires_capture, ifcapture_methodis set tomanual). If theconfirmation_methodisautomatic, payment may be attempted using our client SDKs and the PaymentIntent’s client_secret. Afternext_actions are handled by the client, no additional confirmation is required to complete the payment. If theconfirmation_methodismanual, all payment attempts must be initiated using a secret key. If any actions are required for the payment, the PaymentIntent will return to therequires_confirmationstate after those actions are completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be confirmed. After this limit is reached, any further calls to this endpoint will transition the PaymentIntent to thecanceledstate.
-
-
-
await client.paymentIntent.confirm("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentConfirmRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.incrementAuthorization(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Perform an incremental authorization on an eligible PaymentIntent. To be eligible, the PaymentIntent’s status must be
requires_captureand incremental_authorization_supported must betrue.Incremental authorizations attempt to increase the authorized amount on your customer’s card to the new, higher
amountprovided. Similar to the initial authorization, incremental authorizations can be declined. A single PaymentIntent can call this endpoint multiple times to further increase the authorized amount.If the incremental authorization succeeds, the PaymentIntent object returns with the updated amount. If the incremental authorization fails, a card_declined error returns, and no other fields on the PaymentIntent or Charge update. The PaymentIntent object remains capturable for the previously authorized amount.
Each PaymentIntent can have a maximum of 10 incremental authorization attempts, including declines. After it’s captured, a PaymentIntent can no longer be incremented.
Learn more about incremental authorizations.
-
-
-
await client.paymentIntent.incrementAuthorization("intent", { amount: 1, });
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentIncrementAuthorizationRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentIntent.verifyMicrodeposits(intent, { ...params }) -> Stripe.PaymentIntent
-
-
-
Verifies microdeposits on a PaymentIntent object.
-
-
-
await client.paymentIntent.verifyMicrodeposits("intent");
-
-
-
intent:
string
-
request:
Stripe.PaymentIntentVerifyMicrodepositsRequest
-
requestOptions:
PaymentIntent.RequestOptions
-
-
client.paymentLink.list({ ...params }) -> Stripe.PaymentLinkListResponse
-
-
-
Returns a list of your payment links.
-
-
-
await client.paymentLink.list();
-
-
-
request:
Stripe.PaymentLinkListRequest
-
requestOptions:
PaymentLink.RequestOptions
-
-
client.paymentLink.create({ ...params }) -> Stripe.PaymentLink
-
-
-
Creates a payment link.
-
-
-
await client.paymentLink.create({ line_items: [ { price: "price", quantity: 1, }, ], });
-
-
-
request:
Stripe.PaymentLinkCreateRequest
-
requestOptions:
PaymentLink.RequestOptions
-
-
client.paymentLink.retrieve(paymentLink, { ...params }) -> Stripe.PaymentLink
-
-
-
Retrieve a payment link.
-
-
-
await client.paymentLink.retrieve("payment_link");
-
-
-
paymentLink:
string
-
request:
Stripe.PaymentLinkRetrieveRequest
-
requestOptions:
PaymentLink.RequestOptions
-
-
client.paymentLink.update(paymentLink, { ...params }) -> Stripe.PaymentLink
-
-
-
Updates a payment link.
-
-
-
await client.paymentLink.update("payment_link");
-
-
-
paymentLink:
string
-
request:
Stripe.PaymentLinkUpdateRequest
-
requestOptions:
PaymentLink.RequestOptions
-
-
client.paymentLink.listLineItems(paymentLink, { ...params }) -> Stripe.PaymentLinkListLineItemsResponse
-
-
-
When retrieving a payment link, there is an includable line_items property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
-
-
-
await client.paymentLink.listLineItems("payment_link");
-
-
-
paymentLink:
string
-
request:
Stripe.PaymentLinkListLineItemsRequest
-
requestOptions:
PaymentLink.RequestOptions
-
-
client.paymentMethodConfiguration.list({ ...params }) -> Stripe.PaymentMethodConfigurationListResponse
-
-
-
List payment method configurations
-
-
-
await client.paymentMethodConfiguration.list();
-
-
-
request:
Stripe.PaymentMethodConfigurationListRequest
-
requestOptions:
PaymentMethodConfiguration.RequestOptions
-
-
client.paymentMethodConfiguration.create({ ...params }) -> Stripe.PaymentMethodConfiguration
-
-
-
Creates a payment method configuration
-
-
-
await client.paymentMethodConfiguration.create();
-
-
-
request:
Stripe.PaymentMethodConfigurationCreateRequest
-
requestOptions:
PaymentMethodConfiguration.RequestOptions
-
-
client.paymentMethodConfiguration.retrieve(configuration, { ...params }) -> Stripe.PaymentMethodConfiguration
-
-
-
Retrieve payment method configuration
-
-
-
await client.paymentMethodConfiguration.retrieve("configuration");
-
-
-
configuration:
string
-
request:
Stripe.PaymentMethodConfigurationRetrieveRequest
-
requestOptions:
PaymentMethodConfiguration.RequestOptions
-
-
client.paymentMethodConfiguration.update(configuration, { ...params }) -> Stripe.PaymentMethodConfiguration
-
-
-
Update payment method configuration
-
-
-
await client.paymentMethodConfiguration.update("configuration");
-
-
-
configuration:
string
-
request:
Stripe.PaymentMethodConfigurationUpdateRequest
-
requestOptions:
PaymentMethodConfiguration.RequestOptions
-
-
client.paymentMethodDomain.list({ ...params }) -> Stripe.PaymentMethodDomainListResponse
-
-
-
Lists the details of existing payment method domains.
-
-
-
await client.paymentMethodDomain.list();
-
-
-
request:
Stripe.PaymentMethodDomainListRequest
-
requestOptions:
PaymentMethodDomain.RequestOptions
-
-
client.paymentMethodDomain.create({ ...params }) -> Stripe.PaymentMethodDomain
-
-
-
Creates a payment method domain.
-
-
-
await client.paymentMethodDomain.create({ domain_name: "domain_name", });
-
-
-
request:
Stripe.PaymentMethodDomainCreateRequest
-
requestOptions:
PaymentMethodDomain.RequestOptions
-
-
client.paymentMethodDomain.retrieve(paymentMethodDomain, { ...params }) -> Stripe.PaymentMethodDomain
-
-
-
Retrieves the details of an existing payment method domain.
-
-
-
await client.paymentMethodDomain.retrieve("payment_method_domain");
-
-
-
paymentMethodDomain:
string
-
request:
Stripe.PaymentMethodDomainRetrieveRequest
-
requestOptions:
PaymentMethodDomain.RequestOptions
-
-
client.paymentMethodDomain.update(paymentMethodDomain, { ...params }) -> Stripe.PaymentMethodDomain
-
-
-
Updates an existing payment method domain.
-
-
-
await client.paymentMethodDomain.update("payment_method_domain");
-
-
-
paymentMethodDomain:
string
-
request:
Stripe.PaymentMethodDomainUpdateRequest
-
requestOptions:
PaymentMethodDomain.RequestOptions
-
-
client.paymentMethodDomain.validate(paymentMethodDomain, { ...params }) -> Stripe.PaymentMethodDomain
-
-
-
Some payment methods such as Apple Pay require additional steps to verify a domain. If the requirements weren’t satisfied when the domain was created, the payment method will be inactive on the domain. The payment method doesn’t appear in Elements for this domain until it is active.
To activate a payment method on an existing payment method domain, complete the required validation steps specific to the payment method, and then validate the payment method domain with this endpoint.
Related guides: Payment method domains.
-
-
-
await client.paymentMethodDomain.validate("payment_method_domain");
-
-
-
paymentMethodDomain:
string
-
request:
Stripe.PaymentMethodDomainValidateRequest
-
requestOptions:
PaymentMethodDomain.RequestOptions
-
-
client.paymentMethod.list({ ...params }) -> Stripe.PaymentMethodListResponse
-
-
-
Returns a list of PaymentMethods for Treasury flows. If you want to list the PaymentMethods attached to a Customer for payments, you should use the List a Customer’s PaymentMethods API instead.
-
-
-
await client.paymentMethod.list();
-
-
-
request:
Stripe.PaymentMethodListRequest
-
requestOptions:
PaymentMethod.RequestOptions
-
-
client.paymentMethod.create({ ...params }) -> Stripe.PaymentMethod
-
-
-
Creates a PaymentMethod object. Read the Stripe.js reference to learn how to create PaymentMethods via Stripe.js.
Instead of creating a PaymentMethod directly, we recommend using the PaymentIntents API to accept a payment immediately or the SetupIntent API to collect payment method details ahead of a future payment.
-
-
-
await client.paymentMethod.create();
-
-
-
request:
Stripe.PaymentMethodCreateRequest
-
requestOptions:
PaymentMethod.RequestOptions
-
-
client.paymentMethod.retrieve(paymentMethod, { ...params }) -> Stripe.PaymentMethod
-
-
-
Retrieves a PaymentMethod object attached to the StripeAccount. To retrieve a payment method attached to a Customer, you should use Retrieve a Customer’s PaymentMethods
-
-
-
await client.paymentMethod.retrieve("payment_method");
-
-
-
paymentMethod:
string
-
request:
Stripe.PaymentMethodRetrieveRequest
-
requestOptions:
PaymentMethod.RequestOptions
-
-
client.paymentMethod.update(paymentMethod, { ...params }) -> Stripe.PaymentMethod
-
-
-
Updates a PaymentMethod object. A PaymentMethod must be attached a customer to be updated.
-
-
-
await client.paymentMethod.update("payment_method");
-
-
-
paymentMethod:
string
-
request:
Stripe.PaymentMethodUpdateRequest
-
requestOptions:
PaymentMethod.RequestOptions
-
-
client.paymentMethod.attach(paymentMethod, { ...params }) -> Stripe.PaymentMethod
-
-
-
Attaches a PaymentMethod object to a Customer.
To attach a new PaymentMethod to a customer for future payments, we recommend you use a SetupIntent or a PaymentIntent with setup_future_usage. These approaches will perform any necessary steps to set up the PaymentMethod for future payments. Using the
/v1/payment_methods/:id/attachendpoint without first using a SetupIntent or PaymentIntent withsetup_future_usagedoes not optimize the PaymentMethod for future use, which makes later declines and payment friction more likely. See Optimizing cards for future payments for more information about setting up future payments.To use this PaymentMethod as the default for invoice or subscription payments, set
invoice_settings.default_payment_method, on the Customer to the PaymentMethod’s ID.
-
-
-
await client.paymentMethod.attach("payment_method", { customer: "customer", });
-
-
-
paymentMethod:
string
-
request:
Stripe.PaymentMethodAttachRequest
-
requestOptions:
PaymentMethod.RequestOptions
-
-
client.paymentMethod.detach(paymentMethod, { ...params }) -> Stripe.PaymentMethod
-
-
-
Detaches a PaymentMethod object from a Customer. After a PaymentMethod is detached, it can no longer be used for a payment or re-attached to a Customer.
-
-
-
await client.paymentMethod.detach("payment_method");
-
-
-
paymentMethod:
string
-
request:
Stripe.PaymentMethodDetachRequest
-
requestOptions:
PaymentMethod.RequestOptions
-
-
client.payout.list({ ...params }) -> Stripe.PayoutListResponse
-
-
-
Returns a list of existing payouts sent to third-party bank accounts or payouts that Stripe sent to you. The payouts return in sorted order, with the most recently created payouts appearing first.
-
-
-
await client.payout.list();
-
-
-
request:
Stripe.PayoutListRequest
-
requestOptions:
Payout.RequestOptions
-
-
client.payout.create({ ...params }) -> Stripe.Payout
-
-
-
To send funds to your own bank account, create a new payout object. Your Stripe balance must cover the payout amount. If it doesn’t, you receive an “Insufficient Funds” error.
If your API key is in test mode, money won’t actually be sent, though every other action occurs as if you’re in live mode.
If you create a manual payout on a Stripe account that uses multiple payment source types, you need to specify the source type balance that the payout draws from. The balance object details available and pending amounts by source type.
-
-
-
await client.payout.create({ amount: 1, currency: "currency", });
-
-
-
request:
Stripe.PayoutCreateRequest
-
requestOptions:
Payout.RequestOptions
-
-
client.payout.retrieve(payout, { ...params }) -> Stripe.Payout
-
-
-
Retrieves the details of an existing payout. Supply the unique payout ID from either a payout creation request or the payout list. Stripe returns the corresponding payout information.
-
-
-
await client.payout.retrieve("payout");
-
-
-
payout:
string
-
request:
Stripe.PayoutRetrieveRequest
-
requestOptions:
Payout.RequestOptions
-
-
client.payout.update(payout, { ...params }) -> Stripe.Payout
-
-
-
Updates the specified payout by setting the values of the parameters you pass. We don’t change parameters that you don’t provide. This request only accepts the metadata as arguments.
-
-
-
await client.payout.update("payout");
-
-
-
payout:
string
-
request:
Stripe.PayoutUpdateRequest
-
requestOptions:
Payout.RequestOptions
-
-
client.payout.cancel(payout, { ...params }) -> Stripe.Payout
-
-
-
You can cancel a previously created payout if its status is
pending. Stripe refunds the funds to your available balance. You can’t cancel automatic Stripe payouts.
-
-
-
await client.payout.cancel("payout");
-
-
-
payout:
string
-
request:
Stripe.PayoutCancelRequest
-
requestOptions:
Payout.RequestOptions
-
-
client.payout.reverse(payout, { ...params }) -> Stripe.Payout
-
-
-
Reverses a payout by debiting the destination bank account. At this time, you can only reverse payouts for connected accounts to US bank accounts. If the payout is manual and in the
pendingstatus, use/v1/payouts/:id/cancelinstead.By requesting a reversal through
/v1/payouts/:id/reverse, you confirm that the authorized signatory of the selected bank account authorizes the debit on the bank account and that no other authorization is required.
-
-
-
await client.payout.reverse("payout");
-
-
-
payout:
string
-
request:
Stripe.PayoutReverseRequest
-
requestOptions:
Payout.RequestOptions
-
-
client.plan.list({ ...params }) -> Stripe.PlanListResponse
-
-
-
Returns a list of your plans.
-
-
-
await client.plan.list();
-
-
-
request:
Stripe.PlanListRequest
-
requestOptions:
Plan.RequestOptions
-
-
client.plan.create({ ...params }) -> Stripe.Plan
-
-
-
You can now model subscriptions more flexibly using the Prices API. It replaces the Plans API and is backwards compatible to simplify your migration.
-
-
-
await client.plan.create({ currency: "currency", interval: "day", });
-
-
-
request:
Stripe.PlanCreateRequest
-
requestOptions:
Plan.RequestOptions
-
-
client.plan.retrieve(plan, { ...params }) -> Stripe.Plan
-
-
-
Retrieves the plan with the given ID.
-
-
-
await client.plan.retrieve("plan");
-
-
-
plan:
string
-
request:
Stripe.PlanRetrieveRequest
-
requestOptions:
Plan.RequestOptions
-
-
client.plan.update(plan, { ...params }) -> Stripe.Plan
-
-
-
Updates the specified plan by setting the values of the parameters passed. Any parameters not provided are left unchanged. By design, you cannot change a plan’s ID, amount, currency, or billing cycle.
-
-
-
await client.plan.update("plan");
-
-
-
plan:
string
-
request:
Stripe.PlanUpdateRequest
-
requestOptions:
Plan.RequestOptions
-
-
client.plan.delete(plan, { ...params }) -> Stripe.DeletedPlan
-
-
-
Deleting plans means new subscribers can’t be added. Existing subscribers aren’t affected.
-
-
-
await client.plan.delete("plan");
-
-
-
plan:
string
-
request:
Stripe.PlanDeleteRequest
-
requestOptions:
Plan.RequestOptions
-
-
client.price.list({ ...params }) -> Stripe.PriceListResponse
-
-
-
Returns a list of your active prices, excluding inline prices. For the list of inactive prices, set
activeto false.
-
-
-
await client.price.list();
-
-
-
request:
Stripe.PriceListRequest
-
requestOptions:
Price.RequestOptions
-
-
client.price.create({ ...params }) -> Stripe.Price
-
-
-
Creates a new price for an existing product. The price can be recurring or one-time.
-
-
-
await client.price.create({ currency: "currency", });
-
-
-
request:
Stripe.PriceCreateRequest
-
requestOptions:
Price.RequestOptions
-
-
client.price.search({ ...params }) -> Stripe.PriceSearchResponse
-
-
-
Search for prices you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.price.search({ query: "query", });
-
-
-
request:
Stripe.PriceSearchRequest
-
requestOptions:
Price.RequestOptions
-
-
client.price.retrieve(price, { ...params }) -> Stripe.Price
-
-
-
Retrieves the price with the given ID.
-
-
-
await client.price.retrieve("price");
-
-
-
price:
string
-
request:
Stripe.PriceRetrieveRequest
-
requestOptions:
Price.RequestOptions
-
-
client.price.update(price, { ...params }) -> Stripe.Price
-
-
-
Updates the specified price by setting the values of the parameters passed. Any parameters not provided are left unchanged.
-
-
-
await client.price.update("price");
-
-
-
price:
string
-
request:
Stripe.PriceUpdateRequest
-
requestOptions:
Price.RequestOptions
-
-
client.product.list({ ...params }) -> Stripe.ProductListResponse
-
-
-
Returns a list of your products. The products are returned sorted by creation date, with the most recently created products appearing first.
-
-
-
await client.product.list();
-
-
-
request:
Stripe.ProductListRequest
-
requestOptions:
Product.RequestOptions
-
-
client.product.create({ ...params }) -> Stripe.Product
-
-
-
Creates a new product object.
-
-
-
await client.product.create({ name: "name", });
-
-
-
request:
Stripe.ProductCreateRequest
-
requestOptions:
Product.RequestOptions
-
-
client.product.search({ ...params }) -> Stripe.ProductSearchResponse
-
-
-
Search for products you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.product.search({ query: "query", });
-
-
-
request:
Stripe.ProductSearchRequest
-
requestOptions:
Product.RequestOptions
-
-
client.product.retrieve(id, { ...params }) -> Stripe.Product
-
-
-
Retrieves the details of an existing product. Supply the unique product ID from either a product creation request or the product list, and Stripe will return the corresponding product information.
-
-
-
await client.product.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.ProductRetrieveRequest
-
requestOptions:
Product.RequestOptions
-
-
client.product.update(id, { ...params }) -> Stripe.Product
-
-
-
Updates the specific product by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.product.update("id");
-
-
-
id:
string
-
request:
Stripe.ProductUpdateRequest
-
requestOptions:
Product.RequestOptions
-
-
client.product.delete(id, { ...params }) -> Stripe.DeletedProduct
-
-
-
Delete a product. Deleting a product is only possible if it has no prices associated with it. Additionally, deleting a product with
type=goodis only possible if it has no SKUs associated with it.
-
-
-
await client.product.delete("id");
-
-
-
id:
string
-
request:
Stripe.ProductDeleteRequest
-
requestOptions:
Product.RequestOptions
-
-
client.productFeature.list(product, { ...params }) -> Stripe.ProductFeatureListResponse
-
-
-
Retrieve a list of features for a product
-
-
-
await client.productFeature.list("product");
-
-
-
product:
string
-
request:
Stripe.ProductFeatureListRequest
-
requestOptions:
ProductFeature.RequestOptions
-
-
client.productFeature.create(product, { ...params }) -> Stripe.ProductFeature
-
-
-
Creates a product_feature, which represents a feature attachment to a product
-
-
-
await client.productFeature.create("product", { entitlement_feature: "entitlement_feature", });
-
-
-
product:
string
-
request:
Stripe.ProductFeatureCreateRequest
-
requestOptions:
ProductFeature.RequestOptions
-
-
client.productFeature.retrieve(id, product, { ...params }) -> Stripe.ProductFeature
-
-
-
Retrieves a product_feature, which represents a feature attachment to a product
-
-
-
await client.productFeature.retrieve("id", "product");
-
-
-
id:
string— The ID of the product_feature.
-
product:
string— The ID of the product.
-
request:
Stripe.ProductFeatureRetrieveRequest
-
requestOptions:
ProductFeature.RequestOptions
-
-
client.productFeature.delete(id, product, { ...params }) -> Stripe.DeletedProductFeature
-
-
-
Deletes the feature attachment to a product
-
-
-
await client.productFeature.delete("id", "product");
-
-
-
id:
string
-
product:
string
-
request:
Stripe.ProductFeatureDeleteRequest
-
requestOptions:
ProductFeature.RequestOptions
-
-
client.promotionCode.list({ ...params }) -> Stripe.PromotionCodeListResponse
-
-
-
Returns a list of your promotion codes.
-
-
-
await client.promotionCode.list();
-
-
-
request:
Stripe.PromotionCodeListRequest
-
requestOptions:
PromotionCode.RequestOptions
-
-
client.promotionCode.create({ ...params }) -> Stripe.PromotionCode
-
-
-
A promotion code points to a coupon. You can optionally restrict the code to a specific customer, redemption limit, and expiration date.
-
-
-
await client.promotionCode.create({ coupon: "coupon", });
-
-
-
request:
Stripe.PromotionCodeCreateRequest
-
requestOptions:
PromotionCode.RequestOptions
-
-
client.promotionCode.retrieve(promotionCode, { ...params }) -> Stripe.PromotionCode
-
-
-
Retrieves the promotion code with the given ID. In order to retrieve a promotion code by the customer-facing
codeuse list with the desiredcode.
-
-
-
await client.promotionCode.retrieve("promotion_code");
-
-
-
promotionCode:
string
-
request:
Stripe.PromotionCodeRetrieveRequest
-
requestOptions:
PromotionCode.RequestOptions
-
-
client.promotionCode.update(promotionCode, { ...params }) -> Stripe.PromotionCode
-
-
-
Updates the specified promotion code by setting the values of the parameters passed. Most fields are, by design, not editable.
-
-
-
await client.promotionCode.update("promotion_code");
-
-
-
promotionCode:
string
-
request:
Stripe.PromotionCodeUpdateRequest
-
requestOptions:
PromotionCode.RequestOptions
-
-
client.quote.list({ ...params }) -> Stripe.QuoteListResponse
-
-
-
Returns a list of your quotes.
-
-
-
await client.quote.list();
-
-
-
request:
Stripe.QuoteListRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.create({ ...params }) -> Stripe.Quote
-
-
-
A quote models prices and services for a customer. Default options for
header,description,footer, andexpires_atcan be set in the dashboard via the quote template.
-
-
-
await client.quote.create();
-
-
-
request:
Stripe.QuoteCreateRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.retrieve(quote, { ...params }) -> Stripe.Quote
-
-
-
Retrieves the quote with the given ID.
-
-
-
await client.quote.retrieve("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteRetrieveRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.update(quote, { ...params }) -> Stripe.Quote
-
-
-
A quote models prices and services for a customer.
-
-
-
await client.quote.update("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteUpdateRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.accept(quote, { ...params }) -> Stripe.Quote
-
-
-
Accepts the specified quote.
-
-
-
await client.quote.accept("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteAcceptRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.cancel(quote, { ...params }) -> Stripe.Quote
-
-
-
Cancels the quote.
-
-
-
await client.quote.cancel("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteCancelRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.listComputedUpfrontLineItems(quote, { ...params }) -> Stripe.QuoteListComputedUpfrontLineItemsResponse
-
-
-
When retrieving a quote, there is an includable computed.upfront.line_items property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of upfront line items.
-
-
-
await client.quote.listComputedUpfrontLineItems("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteListComputedUpfrontLineItemsRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.finalizeQuote(quote, { ...params }) -> Stripe.Quote
-
-
-
Finalizes the quote.
-
-
-
await client.quote.finalizeQuote("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteFinalizeQuoteRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.quote.listLineItems(quote, { ...params }) -> Stripe.QuoteListLineItemsResponse
-
-
-
When retrieving a quote, there is an includable line_items property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
-
-
-
await client.quote.listLineItems("quote");
-
-
-
quote:
string
-
request:
Stripe.QuoteListLineItemsRequest
-
requestOptions:
Quote.RequestOptions
-
-
client.refund.list({ ...params }) -> Stripe.RefundListResponse
-
-
-
Returns a list of all refunds you created. We return the refunds in sorted order, with the most recent refunds appearing first. The 10 most recent refunds are always available by default on the Charge object.
-
-
-
await client.refund.list();
-
-
-
request:
Stripe.RefundListRequest
-
requestOptions:
Refund.RequestOptions
-
-
client.refund.create({ ...params }) -> Stripe.Refund
-
-
-
When you create a new refund, you must specify a Charge or a PaymentIntent object on which to create it.
Creating a new refund will refund a charge that has previously been created but not yet refunded. Funds will be refunded to the credit or debit card that was originally charged.
You can optionally refund only part of a charge. You can do so multiple times, until the entire charge has been refunded.
Once entirely refunded, a charge can’t be refunded again. This method will raise an error when called on an already-refunded charge, or when trying to refund more money than is left on a charge.
-
-
-
await client.refund.create();
-
-
-
request:
Stripe.RefundCreateRequest
-
requestOptions:
Refund.RequestOptions
-
-
client.refund.retrieve(refund, { ...params }) -> Stripe.Refund
-
-
-
Retrieves the details of an existing refund.
-
-
-
await client.refund.retrieve("refund");
-
-
-
refund:
string
-
request:
Stripe.RefundRetrieveRequest
-
requestOptions:
Refund.RequestOptions
-
-
client.refund.update(refund, { ...params }) -> Stripe.Refund
-
-
-
Updates the refund that you specify by setting the values of the passed parameters. Any parameters that you don’t provide remain unchanged.
This request only accepts
metadataas an argument.
-
-
-
await client.refund.update("refund");
-
-
-
refund:
string
-
request:
Stripe.RefundUpdateRequest
-
requestOptions:
Refund.RequestOptions
-
-
client.refund.cancel(refund, { ...params }) -> Stripe.Refund
-
-
-
Cancels a refund with a status of
requires_action.You can’t cancel refunds in other states. Only refunds for payment methods that require customer action can enter the
requires_actionstate.
-
-
-
await client.refund.cancel("refund");
-
-
-
refund:
string
-
request:
Stripe.RefundCancelRequest
-
requestOptions:
Refund.RequestOptions
-
-
client.refund.expire(refund, { ...params }) -> Stripe.Refund
-
-
-
Expire a refund with a status of
requires_action.
-
-
-
await client.refund.expire("refund");
-
-
-
refund:
string
-
request:
Stripe.RefundExpireRequest
-
requestOptions:
Refund.RequestOptions
-
-
client.review.list({ ...params }) -> Stripe.ReviewListResponse
-
-
-
Returns a list of
Reviewobjects that haveopenset totrue. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.review.list();
-
-
-
request:
Stripe.ReviewListRequest
-
requestOptions:
Review.RequestOptions
-
-
client.review.retrieve(review, { ...params }) -> Stripe.Review
-
-
-
Retrieves a
Reviewobject.
-
-
-
await client.review.retrieve("review");
-
-
-
review:
string
-
request:
Stripe.ReviewRetrieveRequest
-
requestOptions:
Review.RequestOptions
-
-
client.review.approve(review, { ...params }) -> Stripe.Review
-
-
-
Approves a
Reviewobject, closing it and removing it from the list of reviews.
-
-
-
await client.review.approve("review");
-
-
-
review:
string
-
request:
Stripe.ReviewApproveRequest
-
requestOptions:
Review.RequestOptions
-
-
client.setupAttempt.list({ ...params }) -> Stripe.SetupAttemptListResponse
-
-
-
Returns a list of SetupAttempts that associate with a provided SetupIntent.
-
-
-
await client.setupAttempt.list({ setup_intent: "setup_intent", });
-
-
-
request:
Stripe.SetupAttemptListRequest
-
requestOptions:
SetupAttempt.RequestOptions
-
-
client.setupIntent.list({ ...params }) -> Stripe.SetupIntentListResponse
-
-
-
Returns a list of SetupIntents.
-
-
-
await client.setupIntent.list();
-
-
-
request:
Stripe.SetupIntentListRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.setupIntent.create({ ...params }) -> Stripe.SetupIntent
-
-
-
Creates a SetupIntent object.
After you create the SetupIntent, attach a payment method and confirm it to collect any required permissions to charge the payment method later.
-
-
-
await client.setupIntent.create();
-
-
-
request:
Stripe.SetupIntentCreateRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.setupIntent.retrieve(intent, { ...params }) -> Stripe.SetupIntent
-
-
-
Retrieves the details of a SetupIntent that has previously been created.
Client-side retrieval using a publishable key is allowed when the
client_secretis provided in the query string.When retrieved with a publishable key, only a subset of properties will be returned. Please refer to the SetupIntent object reference for more details.
-
-
-
await client.setupIntent.retrieve("intent");
-
-
-
intent:
string
-
request:
Stripe.SetupIntentRetrieveRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.setupIntent.update(intent, { ...params }) -> Stripe.SetupIntent
-
-
-
Updates a SetupIntent object.
-
-
-
await client.setupIntent.update("intent");
-
-
-
intent:
string
-
request:
Stripe.SetupIntentUpdateRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.setupIntent.cancel(intent, { ...params }) -> Stripe.SetupIntent
-
-
-
You can cancel a SetupIntent object when it’s in one of these statuses:
requires_payment_method,requires_confirmation, orrequires_action.After you cancel it, setup is abandoned and any operations on the SetupIntent fail with an error. You can’t cancel the SetupIntent for a Checkout Session. Expire the Checkout Session instead.
-
-
-
await client.setupIntent.cancel("intent");
-
-
-
intent:
string
-
request:
Stripe.SetupIntentCancelRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.setupIntent.confirm(intent, { ...params }) -> Stripe.SetupIntent
-
-
-
Confirm that your customer intends to set up the current or provided payment method. For example, you would confirm a SetupIntent when a customer hits the “Save” button on a payment method management page on your website.
If the selected payment method does not require any additional steps from the customer, the SetupIntent will transition to the
succeededstatus.Otherwise, it will transition to the
requires_actionstatus and suggest additional actions vianext_action. If setup fails, the SetupIntent will transition to therequires_payment_methodstatus or thecanceledstatus if the confirmation limit is reached.
-
-
-
await client.setupIntent.confirm("intent");
-
-
-
intent:
string
-
request:
Stripe.SetupIntentConfirmRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.setupIntent.verifyMicrodeposits(intent, { ...params }) -> Stripe.SetupIntent
-
-
-
Verifies microdeposits on a SetupIntent object.
-
-
-
await client.setupIntent.verifyMicrodeposits("intent");
-
-
-
intent:
string
-
request:
Stripe.SetupIntentVerifyMicrodepositsRequest
-
requestOptions:
SetupIntent.RequestOptions
-
-
client.shippingRate.list({ ...params }) -> Stripe.ShippingRateListResponse
-
-
-
Returns a list of your shipping rates.
-
-
-
await client.shippingRate.list();
-
-
-
request:
Stripe.ShippingRateListRequest
-
requestOptions:
ShippingRate.RequestOptions
-
-
client.shippingRate.create({ ...params }) -> Stripe.ShippingRate
-
-
-
Creates a new shipping rate object.
-
-
-
await client.shippingRate.create({ display_name: "display_name", });
-
-
-
request:
Stripe.ShippingRateCreateRequest
-
requestOptions:
ShippingRate.RequestOptions
-
-
client.shippingRate.retrieve(shippingRateToken, { ...params }) -> Stripe.ShippingRate
-
-
-
Returns the shipping rate object with the given ID.
-
-
-
await client.shippingRate.retrieve("shipping_rate_token");
-
-
-
shippingRateToken:
string
-
request:
Stripe.ShippingRateRetrieveRequest
-
requestOptions:
ShippingRate.RequestOptions
-
-
client.shippingRate.update(shippingRateToken, { ...params }) -> Stripe.ShippingRate
-
-
-
Updates an existing shipping rate object.
-
-
-
await client.shippingRate.update("shipping_rate_token");
-
-
-
shippingRateToken:
string
-
request:
Stripe.ShippingRateUpdateRequest
-
requestOptions:
ShippingRate.RequestOptions
-
-
client.scheduledQueryRun.list({ ...params }) -> Stripe.ScheduledQueryRunListResponse
-
-
-
Returns a list of scheduled query runs.
-
-
-
await client.scheduledQueryRun.list();
-
-
-
request:
Stripe.ScheduledQueryRunListRequest
-
requestOptions:
ScheduledQueryRun.RequestOptions
-
-
client.scheduledQueryRun.retrieve(scheduledQueryRun, { ...params }) -> Stripe.ScheduledQueryRun
-
-
-
Retrieves the details of an scheduled query run.
-
-
-
await client.scheduledQueryRun.retrieve("scheduled_query_run");
-
-
-
scheduledQueryRun:
string
-
request:
Stripe.ScheduledQueryRunRetrieveRequest
-
requestOptions:
ScheduledQueryRun.RequestOptions
-
-
client.subscriptionItem.list({ ...params }) -> Stripe.SubscriptionItemListResponse
-
-
-
Returns a list of your subscription items for a given subscription.
-
-
-
await client.subscriptionItem.list({ subscription: "subscription", });
-
-
-
request:
Stripe.SubscriptionItemListRequest
-
requestOptions:
SubscriptionItem.RequestOptions
-
-
client.subscriptionItem.create({ ...params }) -> Stripe.SubscriptionItem
-
-
-
Adds a new item to an existing subscription. No existing items will be changed or replaced.
-
-
-
await client.subscriptionItem.create({ subscription: "subscription", });
-
-
-
request:
Stripe.SubscriptionItemCreateRequest
-
requestOptions:
SubscriptionItem.RequestOptions
-
-
client.subscriptionItem.retrieve(item, { ...params }) -> Stripe.SubscriptionItem
-
-
-
Retrieves the subscription item with the given ID.
-
-
-
await client.subscriptionItem.retrieve("item");
-
-
-
item:
string
-
request:
Stripe.SubscriptionItemRetrieveRequest
-
requestOptions:
SubscriptionItem.RequestOptions
-
-
client.subscriptionItem.update(item, { ...params }) -> Stripe.SubscriptionItem
-
-
-
Updates the plan or quantity of an item on a current subscription.
-
-
-
await client.subscriptionItem.update("item");
-
-
-
item:
string
-
request:
Stripe.SubscriptionItemUpdateRequest
-
requestOptions:
SubscriptionItem.RequestOptions
-
-
client.subscriptionItem.delete(item, { ...params }) -> Stripe.DeletedSubscriptionItem
-
-
-
Deletes an item from the subscription. Removing a subscription item from a subscription will not cancel the subscription.
-
-
-
await client.subscriptionItem.delete("item");
-
-
-
item:
string
-
request:
Stripe.SubscriptionItemDeleteRequest
-
requestOptions:
SubscriptionItem.RequestOptions
-
-
client.usageRecordSummary.list(subscriptionItem, { ...params }) -> Stripe.UsageRecordSummaryListResponse
-
-
-
For the specified subscription item, returns a list of summary objects. Each object in the list provides usage information that’s been summarized from multiple usage records and over a subscription billing period (e.g., 15 usage records in the month of September).
The list is sorted in reverse-chronological order (newest first). The first list item represents the most current usage period that hasn’t ended yet. Since new usage records can still be added, the returned summary information for the subscription item’s ID should be seen as unstable until the subscription billing period ends.
-
-
-
await client.usageRecordSummary.list("subscription_item");
-
-
-
subscriptionItem:
string
-
request:
Stripe.UsageRecordSummaryListRequest
-
requestOptions:
UsageRecordSummary.RequestOptions
-
-
client.usageRecord.create(subscriptionItem, { ...params }) -> Stripe.UsageRecord
-
-
-
Creates a usage record for a specified subscription item and date, and fills it with a quantity.
Usage records provide
quantityinformation that Stripe uses to track how much a customer is using your service. With usage information and the pricing model set up by the metered billing plan, Stripe helps you send accurate invoices to your customers.The default calculation for usage is to add up all the
quantityvalues of the usage records within a billing period. You can change this default behavior with the billing plan’saggregate_usageparameter. When there is more than one usage record with the same timestamp, Stripe adds thequantityvalues together. In most cases, this is the desired resolution, however, you can change this behavior with theactionparameter.The default pricing model for metered billing is per-unit pricing. For finer granularity, you can configure metered billing to have a tiered pricing model.
-
-
-
await client.usageRecord.create("subscription_item", { quantity: 1, });
-
-
-
subscriptionItem:
string
-
request:
Stripe.UsageRecordCreateRequest
-
requestOptions:
UsageRecord.RequestOptions
-
-
client.subscriptionSchedule.list({ ...params }) -> Stripe.SubscriptionScheduleListResponse
-
-
-
Retrieves the list of your subscription schedules.
-
-
-
await client.subscriptionSchedule.list();
-
-
-
request:
Stripe.SubscriptionScheduleListRequest
-
requestOptions:
SubscriptionSchedule.RequestOptions
-
-
client.subscriptionSchedule.create({ ...params }) -> Stripe.SubscriptionSchedule
-
-
-
Creates a new subscription schedule object. Each customer can have up to 500 active or scheduled subscriptions.
-
-
-
await client.subscriptionSchedule.create();
-
-
-
request:
Stripe.SubscriptionScheduleCreateRequest
-
requestOptions:
SubscriptionSchedule.RequestOptions
-
-
client.subscriptionSchedule.retrieve(schedule, { ...params }) -> Stripe.SubscriptionSchedule
-
-
-
Retrieves the details of an existing subscription schedule. You only need to supply the unique subscription schedule identifier that was returned upon subscription schedule creation.
-
-
-
await client.subscriptionSchedule.retrieve("schedule");
-
-
-
schedule:
string
-
request:
Stripe.SubscriptionScheduleRetrieveRequest
-
requestOptions:
SubscriptionSchedule.RequestOptions
-
-
client.subscriptionSchedule.update(schedule, { ...params }) -> Stripe.SubscriptionSchedule
-
-
-
Updates an existing subscription schedule.
-
-
-
await client.subscriptionSchedule.update("schedule");
-
-
-
schedule:
string
-
request:
Stripe.SubscriptionScheduleUpdateRequest
-
requestOptions:
SubscriptionSchedule.RequestOptions
-
-
client.subscriptionSchedule.cancel(schedule, { ...params }) -> Stripe.SubscriptionSchedule
-
-
-
Cancels a subscription schedule and its associated subscription immediately (if the subscription schedule has an active subscription). A subscription schedule can only be canceled if its status is
not_startedoractive.
-
-
-
await client.subscriptionSchedule.cancel("schedule");
-
-
-
schedule:
string
-
request:
Stripe.SubscriptionScheduleCancelRequest
-
requestOptions:
SubscriptionSchedule.RequestOptions
-
-
client.subscriptionSchedule.release(schedule, { ...params }) -> Stripe.SubscriptionSchedule
-
-
-
Releases the subscription schedule immediately, which will stop scheduling of its phases, but leave any existing subscription in place. A schedule can only be released if its status is
not_startedoractive. If the subscription schedule is currently associated with a subscription, releasing it will remove itssubscriptionproperty and set the subscription’s ID to thereleased_subscriptionproperty.
-
-
-
await client.subscriptionSchedule.release("schedule");
-
-
-
schedule:
string
-
request:
Stripe.SubscriptionScheduleReleaseRequest
-
requestOptions:
SubscriptionSchedule.RequestOptions
-
-
client.subscription.list({ ...params }) -> Stripe.SubscriptionListResponse
-
-
-
By default, returns a list of subscriptions that have not been canceled. In order to list canceled subscriptions, specify
status=canceled.
-
-
-
await client.subscription.list();
-
-
-
request:
Stripe.SubscriptionListRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.create({ ...params }) -> Stripe.Subscription
-
-
-
Creates a new subscription on an existing customer. Each customer can have up to 500 active or scheduled subscriptions.
When you create a subscription with
collection_method=charge_automatically, the first invoice is finalized as part of the request. Thepayment_behaviorparameter determines the exact behavior of the initial payment.To start subscriptions where the first invoice always begins in a
draftstatus, use subscription schedules instead. Schedules provide the flexibility to model more complex billing configurations that change over time.
-
-
-
await client.subscription.create({ customer: "customer", });
-
-
-
request:
Stripe.SubscriptionCreateRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.search({ ...params }) -> Stripe.SubscriptionSearchResponse
-
-
-
Search for subscriptions you’ve previously created using Stripe’s Search Query Language. Don’t use search in read-after-write flows where strict consistency is necessary. Under normal operating conditions, data is searchable in less than a minute. Occasionally, propagation of new or updated data can be up to an hour behind during outages. Search functionality is not available to merchants in India.
-
-
-
await client.subscription.search({ query: "query", });
-
-
-
request:
Stripe.SubscriptionSearchRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.retrieve(subscriptionExposedId, { ...params }) -> Stripe.Subscription
-
-
-
Retrieves the subscription with the given ID.
-
-
-
await client.subscription.retrieve("subscription_exposed_id");
-
-
-
subscriptionExposedId:
string
-
request:
Stripe.SubscriptionRetrieveRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.update(subscriptionExposedId, { ...params }) -> Stripe.Subscription
-
-
-
Updates an existing subscription to match the specified parameters. When changing prices or quantities, we optionally prorate the price we charge next month to make up for any price changes. To preview how the proration is calculated, use the create preview endpoint.
By default, we prorate subscription changes. For example, if a customer signs up on May 1 for a 100 price, they’ll be billed 100 immediately. If on May 15 they switch to a 200 price, then on June 1 they’ll be billed 250 (200 for a renewal of her subscription, plus a 50 prorating adjustment for half of the previous month’s 100 difference). Similarly, a downgrade generates a credit that is applied to the next invoice. We also prorate when you make quantity changes.
Switching prices does not normally change the billing date or generate an immediate charge unless:
- The billing interval is changed (for example, from monthly to yearly).
- The subscription moves from free to paid.
- A trial starts or ends.
In these cases, we apply a credit for the unused time on the previous price, immediately charge the customer using the new price, and reset the billing date. Learn about how Stripe immediately attempts payment for subscription changes.
If you want to charge for an upgrade immediately, pass
proration_behaviorasalways_invoiceto create prorations, automatically invoice the customer for those proration adjustments, and attempt to collect payment. If you passcreate_prorations, the prorations are created but not automatically invoiced. If you want to bill the customer for the prorations before the subscription’s renewal date, you need to manually invoice the customer.If you don’t want to prorate, set the
proration_behavioroption tonone. With this option, the customer is billed 100 on May 1 and 200 on June 1. Similarly, if you setproration_behaviortononewhen switching between different billing intervals (for example, from monthly to yearly), we don’t generate any credits for the old subscription’s unused time. We still reset the billing date and bill immediately for the new subscription.Updating the quantity on a subscription many times in an hour may result in rate limiting. If you need to bill for a frequently changing quantity, consider integrating usage-based billing instead.
-
-
-
await client.subscription.update("subscription_exposed_id");
-
-
-
subscriptionExposedId:
string
-
request:
Stripe.SubscriptionUpdateRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.cancel(subscriptionExposedId, { ...params }) -> Stripe.Subscription
-
-
-
Cancels a customer’s subscription immediately. The customer won’t be charged again for the subscription. After it’s canceled, you can no longer update the subscription or its metadata.
Any pending invoice items that you’ve created are still charged at the end of the period, unless manually deleted. If you’ve set the subscription to cancel at the end of the period, any pending prorations are also left in place and collected at the end of the period. But if the subscription is set to cancel immediately, pending prorations are removed.
By default, upon subscription cancellation, Stripe stops automatic collection of all finalized invoices for the customer. This is intended to prevent unexpected payment attempts after the customer has canceled a subscription. However, you can resume automatic collection of the invoices manually after subscription cancellation to have us proceed. Or, you could check for unpaid invoices before allowing the customer to cancel the subscription at all.
-
-
-
await client.subscription.cancel("subscription_exposed_id");
-
-
-
subscriptionExposedId:
string
-
request:
Stripe.SubscriptionCancelRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.deleteDiscount(subscriptionExposedId, { ...params }) -> Stripe.DeletedDiscount
-
-
-
Removes the currently applied discount on a subscription.
-
-
-
await client.subscription.deleteDiscount("subscription_exposed_id");
-
-
-
subscriptionExposedId:
string
-
request:
Stripe.SubscriptionDeleteDiscountRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.subscription.resume(subscription, { ...params }) -> Stripe.Subscription
-
-
-
Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become
active, and if payment fails the subscription will bepast_due. The resumption invoice will void automatically if not paid by the expiration date.
-
-
-
await client.subscription.resume("subscription");
-
-
-
subscription:
string
-
request:
Stripe.SubscriptionResumeRequest
-
requestOptions:
Subscription.RequestOptions
-
-
client.taxCode.list({ ...params }) -> Stripe.TaxCodeListResponse
-
-
-
A list of all tax codes available to add to Products in order to allow specific tax calculations.
-
-
-
await client.taxCode.list();
-
-
-
request:
Stripe.TaxCodeListRequest
-
requestOptions:
TaxCode.RequestOptions
-
-
client.taxCode.retrieve(id, { ...params }) -> Stripe.TaxCode
-
-
-
Retrieves the details of an existing tax code. Supply the unique tax code ID and Stripe will return the corresponding tax code information.
-
-
-
await client.taxCode.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.TaxCodeRetrieveRequest
-
requestOptions:
TaxCode.RequestOptions
-
-
client.taxRate.list({ ...params }) -> Stripe.TaxRateListResponse
-
-
-
Returns a list of your tax rates. Tax rates are returned sorted by creation date, with the most recently created tax rates appearing first.
-
-
-
await client.taxRate.list();
-
-
-
request:
Stripe.TaxRateListRequest
-
requestOptions:
TaxRate.RequestOptions
-
-
client.taxRate.create({ ...params }) -> Stripe.TaxRate
-
-
-
Creates a new tax rate.
-
-
-
await client.taxRate.create({ display_name: "display_name", inclusive: true, percentage: 1.1, });
-
-
-
request:
Stripe.TaxRateCreateRequest
-
requestOptions:
TaxRate.RequestOptions
-
-
client.taxRate.retrieve(taxRate, { ...params }) -> Stripe.TaxRate
-
-
-
Retrieves a tax rate with the given ID
-
-
-
await client.taxRate.retrieve("tax_rate");
-
-
-
taxRate:
string
-
request:
Stripe.TaxRateRetrieveRequest
-
requestOptions:
TaxRate.RequestOptions
-
-
client.taxRate.update(taxRate, { ...params }) -> Stripe.TaxRate
-
-
-
Updates an existing tax rate.
-
-
-
await client.taxRate.update("tax_rate");
-
-
-
taxRate:
string
-
request:
Stripe.TaxRateUpdateRequest
-
requestOptions:
TaxRate.RequestOptions
-
-
client.token.create({ ...params }) -> Stripe.Token
-
-
-
Creates a single-use token that represents a bank account’s details. You can use this token with any v1 API method in place of a bank account dictionary. You can only use this token once. To do so, attach it to a connected account where controller.requirement_collection is
application, which includes Custom accounts.
-
-
-
await client.token.create();
-
-
-
request:
Stripe.TokenCreateRequest
-
requestOptions:
Token.RequestOptions
-
-
client.token.retrieve(token, { ...params }) -> Stripe.Token
-
-
-
Retrieves the token with the given ID.
-
-
-
await client.token.retrieve("token");
-
-
-
token:
string
-
request:
Stripe.TokenRetrieveRequest
-
requestOptions:
Token.RequestOptions
-
-
client.topup.list({ ...params }) -> Stripe.TopupListResponse
-
-
-
Returns a list of top-ups.
-
-
-
await client.topup.list();
-
-
-
request:
Stripe.TopupListRequest
-
requestOptions:
Topup.RequestOptions
-
-
client.topup.create({ ...params }) -> Stripe.Topup
-
-
-
Top up the balance of an account
-
-
-
await client.topup.create({ amount: 1, currency: "currency", });
-
-
-
request:
Stripe.TopupCreateRequest
-
requestOptions:
Topup.RequestOptions
-
-
client.topup.retrieve(topup, { ...params }) -> Stripe.Topup
-
-
-
Retrieves the details of a top-up that has previously been created. Supply the unique top-up ID that was returned from your previous request, and Stripe will return the corresponding top-up information.
-
-
-
await client.topup.retrieve("topup");
-
-
-
topup:
string
-
request:
Stripe.TopupRetrieveRequest
-
requestOptions:
Topup.RequestOptions
-
-
client.topup.update(topup, { ...params }) -> Stripe.Topup
-
-
-
Updates the metadata of a top-up. Other top-up details are not editable by design.
-
-
-
await client.topup.update("topup");
-
-
-
topup:
string
-
request:
Stripe.TopupUpdateRequest
-
requestOptions:
Topup.RequestOptions
-
-
client.topup.cancel(topup, { ...params }) -> Stripe.Topup
-
-
-
Cancels a top-up. Only pending top-ups can be canceled.
-
-
-
await client.topup.cancel("topup");
-
-
-
topup:
string
-
request:
Stripe.TopupCancelRequest
-
requestOptions:
Topup.RequestOptions
-
-
client.transfer.list({ ...params }) -> Stripe.TransferListResponse
-
-
-
Returns a list of existing transfers sent to connected accounts. The transfers are returned in sorted order, with the most recently created transfers appearing first.
-
-
-
await client.transfer.list();
-
-
-
request:
Stripe.TransferListRequest
-
requestOptions:
Transfer.RequestOptions
-
-
client.transfer.create({ ...params }) -> Stripe.Transfer
-
-
-
To send funds from your Stripe account to a connected account, you create a new transfer object. Your Stripe balance must be able to cover the transfer amount, or you’ll receive an “Insufficient Funds” error.
-
-
-
await client.transfer.create({ currency: "currency", destination: "destination", });
-
-
-
request:
Stripe.TransferCreateRequest
-
requestOptions:
Transfer.RequestOptions
-
-
client.transfer.retrieve(transfer, { ...params }) -> Stripe.Transfer
-
-
-
Retrieves the details of an existing transfer. Supply the unique transfer ID from either a transfer creation request or the transfer list, and Stripe will return the corresponding transfer information.
-
-
-
await client.transfer.retrieve("transfer");
-
-
-
transfer:
string
-
request:
Stripe.TransferRetrieveRequest
-
requestOptions:
Transfer.RequestOptions
-
-
client.transfer.update(transfer, { ...params }) -> Stripe.Transfer
-
-
-
Updates the specified transfer by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
This request accepts only metadata as an argument.
-
-
-
await client.transfer.update("transfer");
-
-
-
transfer:
string
-
request:
Stripe.TransferUpdateRequest
-
requestOptions:
Transfer.RequestOptions
-
-
client.transferReversal.list(id, { ...params }) -> Stripe.TransferReversalListResponse
-
-
-
You can see a list of the reversals belonging to a specific transfer. Note that the 10 most recent reversals are always available by default on the transfer object. If you need more than those 10, you can use this API method and the
limitandstarting_afterparameters to page through additional reversals.
-
-
-
await client.transferReversal.list("id");
-
-
-
id:
string
-
request:
Stripe.TransferReversalListRequest
-
requestOptions:
TransferReversal.RequestOptions
-
-
client.transferReversal.create(id, { ...params }) -> Stripe.TransferReversal
-
-
-
When you create a new reversal, you must specify a transfer to create it on.
When reversing transfers, you can optionally reverse part of the transfer. You can do so as many times as you wish until the entire transfer has been reversed.
Once entirely reversed, a transfer can’t be reversed again. This method will return an error when called on an already-reversed transfer, or when trying to reverse more money than is left on a transfer.
-
-
-
await client.transferReversal.create("id");
-
-
-
id:
string
-
request:
Stripe.TransferReversalCreateRequest
-
requestOptions:
TransferReversal.RequestOptions
-
-
client.transferReversal.retrieve(id, transfer, { ...params }) -> Stripe.TransferReversal
-
-
-
By default, you can see the 10 most recent reversals stored directly on the transfer object, but you can also retrieve details about a specific reversal stored on the transfer.
-
-
-
await client.transferReversal.retrieve("id", "transfer");
-
-
-
id:
string
-
transfer:
string
-
request:
Stripe.TransferReversalRetrieveRequest
-
requestOptions:
TransferReversal.RequestOptions
-
-
client.transferReversal.update(id, transfer, { ...params }) -> Stripe.TransferReversal
-
-
-
Updates the specified reversal by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
This request only accepts metadata and description as arguments.
-
-
-
await client.transferReversal.update("id", "transfer");
-
-
-
id:
string
-
transfer:
string
-
request:
Stripe.TransferReversalUpdateRequest
-
requestOptions:
TransferReversal.RequestOptions
-
-
client.webhookEndpoint.list({ ...params }) -> Stripe.WebhookEndpointListResponse
-
-
-
Returns a list of your webhook endpoints.
-
-
-
await client.webhookEndpoint.list();
-
-
-
request:
Stripe.WebhookEndpointListRequest
-
requestOptions:
WebhookEndpoint.RequestOptions
-
-
client.webhookEndpoint.create({ ...params }) -> Stripe.WebhookEndpoint
-
-
-
A webhook endpoint must have a
urland a list ofenabled_events. You may optionally specify the Booleanconnectparameter. If set to true, then a Connect webhook endpoint that notifies the specifiedurlabout events from all connected accounts is created; otherwise an account webhook endpoint that notifies the specifiedurlonly about events from your account is created. You can also create webhook endpoints in the webhooks settings section of the Dashboard.
-
-
-
await client.webhookEndpoint.create({ enabled_events: ["*"], url: "url", });
-
-
-
request:
Stripe.WebhookEndpointCreateRequest
-
requestOptions:
WebhookEndpoint.RequestOptions
-
-
client.webhookEndpoint.retrieve(webhookEndpoint, { ...params }) -> Stripe.WebhookEndpoint
-
-
-
Retrieves the webhook endpoint with the given ID.
-
-
-
await client.webhookEndpoint.retrieve("webhook_endpoint");
-
-
-
webhookEndpoint:
string
-
request:
Stripe.WebhookEndpointRetrieveRequest
-
requestOptions:
WebhookEndpoint.RequestOptions
-
-
client.webhookEndpoint.update(webhookEndpoint, { ...params }) -> Stripe.WebhookEndpoint
-
-
-
Updates the webhook endpoint. You may edit the
url, the list ofenabled_events, and the status of your endpoint.
-
-
-
await client.webhookEndpoint.update("webhook_endpoint");
-
-
-
webhookEndpoint:
string
-
request:
Stripe.WebhookEndpointUpdateRequest
-
requestOptions:
WebhookEndpoint.RequestOptions
-
-
client.webhookEndpoint.delete(webhookEndpoint, { ...params }) -> Stripe.DeletedWebhookEndpoint
-
-
-
You can also delete webhook endpoints via the webhook endpoint management page of the Stripe dashboard.
-
-
-
await client.webhookEndpoint.delete("webhook_endpoint");
-
-
-
webhookEndpoint:
string
-
request:
Stripe.WebhookEndpointDeleteRequest
-
requestOptions:
WebhookEndpoint.RequestOptions
-
-
client.apps.secret.list({ ...params }) -> Stripe.SecretListResponse
-
-
-
List all secrets stored on the given scope.
-
-
-
await client.apps.secret.list({ scope: { type: "account", user: undefined, }, });
-
-
-
request:
Stripe.apps.SecretListRequest
-
requestOptions:
Secret.RequestOptions
-
-
client.apps.secret.create({ ...params }) -> Stripe.AppsSecret
-
-
-
Create or replace a secret in the secret store.
-
-
-
await client.apps.secret.create({ name: "name", payload: "payload", scope: { type: "account", }, });
-
-
-
request:
Stripe.apps.SecretCreateRequest
-
requestOptions:
Secret.RequestOptions
-
-
client.apps.secret.deleteWhere({ ...params }) -> Stripe.AppsSecret
-
-
-
Deletes a secret from the secret store by name and scope.
-
-
-
await client.apps.secret.deleteWhere({ name: "name", scope: { type: "account", }, });
-
-
-
request:
Stripe.apps.SecretDeleteWhereRequest
-
requestOptions:
Secret.RequestOptions
-
-
client.apps.secret.find({ ...params }) -> Stripe.AppsSecret
-
-
-
Finds a secret in the secret store by name and scope.
-
-
-
await client.apps.secret.find({ name: "blackcurrant............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................", scope: { type: "account", user: undefined, }, });
-
-
-
request:
Stripe.apps.SecretFindRequest
-
requestOptions:
Secret.RequestOptions
-
-
client.billing.alert.list({ ...params }) -> Stripe.AlertListResponse
-
-
-
Lists billing active and inactive alerts
-
-
-
await client.billing.alert.list();
-
-
-
request:
Stripe.billing.AlertListRequest
-
requestOptions:
Alert.RequestOptions
-
-
client.billing.alert.create({ ...params }) -> Stripe.BillingAlert
-
-
-
Creates a billing alert
-
-
-
await client.billing.alert.create({ title: "title", });
-
-
-
request:
Stripe.billing.AlertCreateRequest
-
requestOptions:
Alert.RequestOptions
-
-
client.billing.alert.retrieve(id, { ...params }) -> Stripe.BillingAlert
-
-
-
Retrieves a billing alert given an ID
-
-
-
await client.billing.alert.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.billing.AlertRetrieveRequest
-
requestOptions:
Alert.RequestOptions
-
-
client.billing.alert.activate(id, { ...params }) -> Stripe.BillingAlert
-
-
-
Reactivates this alert, allowing it to trigger again.
-
-
-
await client.billing.alert.activate("id");
-
-
-
id:
string
-
request:
Stripe.billing.AlertActivateRequest
-
requestOptions:
Alert.RequestOptions
-
-
client.billing.alert.archive(id, { ...params }) -> Stripe.BillingAlert
-
-
-
Archives this alert, removing it from the list view and APIs. This is non-reversible.
-
-
-
await client.billing.alert.archive("id");
-
-
-
id:
string
-
request:
Stripe.billing.AlertArchiveRequest
-
requestOptions:
Alert.RequestOptions
-
-
client.billing.alert.deactivate(id, { ...params }) -> Stripe.BillingAlert
-
-
-
Deactivates this alert, preventing it from triggering.
-
-
-
await client.billing.alert.deactivate("id");
-
-
-
id:
string
-
request:
Stripe.billing.AlertDeactivateRequest
-
requestOptions:
Alert.RequestOptions
-
-
client.billing.creditBalanceSummary.retrieve({ ...params }) -> Stripe.BillingCreditBalanceSummary
-
-
-
Retrieves the credit balance summary for a customer.
-
-
-
await client.billing.creditBalanceSummary.retrieve({ customer: "blackcurrant............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................", filter: { applicability_scope: undefined, credit_grant: undefined, type: "applicability_scope", }, });
-
-
-
request:
Stripe.billing.CreditBalanceSummaryRetrieveRequest
-
requestOptions:
CreditBalanceSummary.RequestOptions
-
-
client.billing.creditBalanceTransaction.list({ ...params }) -> Stripe.CreditBalanceTransactionListResponse
-
-
-
Retrieve a list of credit balance transactions.
-
-
-
await client.billing.creditBalanceTransaction.list({ customer: "customer", });
-
-
-
request:
Stripe.billing.CreditBalanceTransactionListRequest
-
requestOptions:
CreditBalanceTransaction.RequestOptions
-
-
client.billing.creditBalanceTransaction.retrieve(id, { ...params }) -> Stripe.BillingCreditBalanceTransaction
-
-
-
Retrieves a credit balance transaction.
-
-
-
await client.billing.creditBalanceTransaction.retrieve("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.CreditBalanceTransactionRetrieveRequest
-
requestOptions:
CreditBalanceTransaction.RequestOptions
-
-
client.billing.creditGrant.list({ ...params }) -> Stripe.CreditGrantListResponse
-
-
-
Retrieve a list of credit grants.
-
-
-
await client.billing.creditGrant.list();
-
-
-
request:
Stripe.billing.CreditGrantListRequest
-
requestOptions:
CreditGrant.RequestOptions
-
-
client.billing.creditGrant.create({ ...params }) -> Stripe.BillingCreditGrant
-
-
-
Creates a credit grant.
-
-
-
await client.billing.creditGrant.create({ amount: { type: "monetary", }, applicability_config: { scope: { price_type: "metered", }, }, category: "paid", customer: "customer", });
-
-
-
request:
Stripe.billing.CreditGrantCreateRequest
-
requestOptions:
CreditGrant.RequestOptions
-
-
client.billing.creditGrant.retrieve(id, { ...params }) -> Stripe.BillingCreditGrant
-
-
-
Retrieves a credit grant.
-
-
-
await client.billing.creditGrant.retrieve("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.CreditGrantRetrieveRequest
-
requestOptions:
CreditGrant.RequestOptions
-
-
client.billing.creditGrant.update(id, { ...params }) -> Stripe.BillingCreditGrant
-
-
-
Updates a credit grant.
-
-
-
await client.billing.creditGrant.update("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.CreditGrantUpdateRequest
-
requestOptions:
CreditGrant.RequestOptions
-
-
client.billing.creditGrant.expire(id, { ...params }) -> Stripe.BillingCreditGrant
-
-
-
Expires a credit grant.
-
-
-
await client.billing.creditGrant.expire("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.CreditGrantExpireRequest
-
requestOptions:
CreditGrant.RequestOptions
-
-
client.billing.creditGrant.voidGrant(id, { ...params }) -> Stripe.BillingCreditGrant
-
-
-
Voids a credit grant.
-
-
-
await client.billing.creditGrant.voidGrant("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.CreditGrantVoidGrantRequest
-
requestOptions:
CreditGrant.RequestOptions
-
-
client.billing.meterEventAdjustment.create({ ...params }) -> Stripe.BillingMeterEventAdjustment
-
-
-
Creates a billing meter event adjustment.
-
-
-
await client.billing.meterEventAdjustment.create({ event_name: "event_name", });
-
-
-
request:
Stripe.billing.MeterEventAdjustmentCreateRequest
-
requestOptions:
MeterEventAdjustment.RequestOptions
-
-
client.billing.meterEvent.create({ ...params }) -> Stripe.BillingMeterEvent
-
-
-
Creates a billing meter event.
-
-
-
await client.billing.meterEvent.create({ event_name: "event_name", payload: { key: "value", }, });
-
-
-
request:
Stripe.billing.MeterEventCreateRequest
-
requestOptions:
MeterEvent.RequestOptions
-
-
client.billing.meter.list({ ...params }) -> Stripe.MeterListResponse
-
-
-
Retrieve a list of billing meters.
-
-
-
await client.billing.meter.list();
-
-
-
request:
Stripe.billing.MeterListRequest
-
requestOptions:
Meter.RequestOptions
-
-
client.billing.meter.create({ ...params }) -> Stripe.BillingMeter
-
-
-
Creates a billing meter.
-
-
-
await client.billing.meter.create({ default_aggregation: { formula: "count", }, display_name: "display_name", event_name: "event_name", });
-
-
-
request:
Stripe.billing.MeterCreateRequest
-
requestOptions:
Meter.RequestOptions
-
-
client.billing.meter.retrieve(id, { ...params }) -> Stripe.BillingMeter
-
-
-
Retrieves a billing meter given an ID.
-
-
-
await client.billing.meter.retrieve("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.MeterRetrieveRequest
-
requestOptions:
Meter.RequestOptions
-
-
client.billing.meter.update(id, { ...params }) -> Stripe.BillingMeter
-
-
-
Updates a billing meter.
-
-
-
await client.billing.meter.update("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.MeterUpdateRequest
-
requestOptions:
Meter.RequestOptions
-
-
client.billing.meter.deactivate(id, { ...params }) -> Stripe.BillingMeter
-
-
-
When a meter is deactivated, no more meter events will be accepted for this meter. You can’t attach a deactivated meter to a price.
-
-
-
await client.billing.meter.deactivate("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.MeterDeactivateRequest
-
requestOptions:
Meter.RequestOptions
-
-
client.billing.meter.reactivate(id, { ...params }) -> Stripe.BillingMeter
-
-
-
When a meter is reactivated, events for this meter can be accepted and you can attach the meter to a price.
-
-
-
await client.billing.meter.reactivate("id");
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.MeterReactivateRequest
-
requestOptions:
Meter.RequestOptions
-
-
client.billing.meterEventSummary.list(id, { ...params }) -> Stripe.MeterEventSummaryListResponse
-
-
-
Retrieve a list of billing meter event summaries.
-
-
-
await client.billing.meterEventSummary.list("id", { customer: "customer", end_time: 1, start_time: 1, });
-
-
-
id:
string— Unique identifier for the object.
-
request:
Stripe.billing.MeterEventSummaryListRequest
-
requestOptions:
MeterEventSummary.RequestOptions
-
-
client.billingPortal.configuration.list({ ...params }) -> Stripe.ConfigurationListResponse
-
-
-
Returns a list of configurations that describe the functionality of the customer portal.
-
-
-
await client.billingPortal.configuration.list();
-
-
-
request:
Stripe.billingPortal.ConfigurationListRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.billingPortal.configuration.create({ ...params }) -> Stripe.BillingPortalConfiguration
-
-
-
Creates a configuration that describes the functionality and behavior of a PortalSession
-
-
-
await client.billingPortal.configuration.create({ features: {}, });
-
-
-
request:
Stripe.billingPortal.ConfigurationCreateRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.billingPortal.configuration.retrieve(configuration, { ...params }) -> Stripe.BillingPortalConfiguration
-
-
-
Retrieves a configuration that describes the functionality of the customer portal.
-
-
-
await client.billingPortal.configuration.retrieve("configuration");
-
-
-
configuration:
string
-
request:
Stripe.billingPortal.ConfigurationRetrieveRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.billingPortal.configuration.update(configuration, { ...params }) -> Stripe.BillingPortalConfiguration
-
-
-
Updates a configuration that describes the functionality of the customer portal.
-
-
-
await client.billingPortal.configuration.update("configuration");
-
-
-
configuration:
string
-
request:
Stripe.billingPortal.ConfigurationUpdateRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.billingPortal.session.create({ ...params }) -> Stripe.BillingPortalSession
-
-
-
Creates a session of the customer portal.
-
-
-
await client.billingPortal.session.create({ customer: "customer", });
-
-
-
request:
Stripe.billingPortal.SessionCreateRequest
-
requestOptions:
Session.RequestOptions
-
-
client.checkout.session.list({ ...params }) -> Stripe.SessionListResponse
-
-
-
Returns a list of Checkout Sessions.
-
-
-
await client.checkout.session.list();
-
-
-
request:
Stripe.checkout.SessionListRequest
-
requestOptions:
Session.RequestOptions
-
-
client.checkout.session.create({ ...params }) -> Stripe.CheckoutSession
-
-
-
Creates a Session object.
-
-
-
await client.checkout.session.create();
-
-
-
request:
Stripe.checkout.SessionCreateRequest
-
requestOptions:
Session.RequestOptions
-
-
client.checkout.session.retrieve(session, { ...params }) -> Stripe.CheckoutSession
-
-
-
Retrieves a Session object.
-
-
-
await client.checkout.session.retrieve("session");
-
-
-
session:
string
-
request:
Stripe.checkout.SessionRetrieveRequest
-
requestOptions:
Session.RequestOptions
-
-
client.checkout.session.update(session, { ...params }) -> Stripe.CheckoutSession
-
-
-
Updates a Session object.
-
-
-
await client.checkout.session.update("session");
-
-
-
session:
string
-
request:
Stripe.checkout.SessionUpdateRequest
-
requestOptions:
Session.RequestOptions
-
-
client.checkout.session.expire(session, { ...params }) -> Stripe.CheckoutSession
-
-
-
A Session can be expired when it is in one of these statuses:
openAfter it expires, a customer can’t complete a Session and customers loading the Session see a message saying the Session is expired.
-
-
-
await client.checkout.session.expire("session");
-
-
-
session:
string
-
request:
Stripe.checkout.SessionExpireRequest
-
requestOptions:
Session.RequestOptions
-
-
client.checkout.session.listLineItems(session, { ...params }) -> Stripe.SessionListLineItemsResponse
-
-
-
When retrieving a Checkout Session, there is an includable line_items property containing the first handful of those items. There is also a URL where you can retrieve the full (paginated) list of line items.
-
-
-
await client.checkout.session.listLineItems("session");
-
-
-
session:
string
-
request:
Stripe.checkout.SessionListLineItemsRequest
-
requestOptions:
Session.RequestOptions
-
-
client.climate.order.list({ ...params }) -> Stripe.OrderListResponse
-
-
-
Lists all Climate order objects. The orders are returned sorted by creation date, with the most recently created orders appearing first.
-
-
-
await client.climate.order.list();
-
-
-
request:
Stripe.climate.OrderListRequest
-
requestOptions:
Order.RequestOptions
-
-
client.climate.order.create({ ...params }) -> Stripe.ClimateOrder
-
-
-
Creates a Climate order object for a given Climate product. The order will be processed immediately after creation and payment will be deducted your Stripe balance.
-
-
-
await client.climate.order.create({ product: "product", });
-
-
-
request:
Stripe.climate.OrderCreateRequest
-
requestOptions:
Order.RequestOptions
-
-
client.climate.order.retrieve(order, { ...params }) -> Stripe.ClimateOrder
-
-
-
Retrieves the details of a Climate order object with the given ID.
-
-
-
await client.climate.order.retrieve("order");
-
-
-
order:
string— Unique identifier of the order.
-
request:
Stripe.climate.OrderRetrieveRequest
-
requestOptions:
Order.RequestOptions
-
-
client.climate.order.update(order, { ...params }) -> Stripe.ClimateOrder
-
-
-
Updates the specified order by setting the values of the parameters passed.
-
-
-
await client.climate.order.update("order");
-
-
-
order:
string— Unique identifier of the order.
-
request:
Stripe.climate.OrderUpdateRequest
-
requestOptions:
Order.RequestOptions
-
-
client.climate.order.cancel(order, { ...params }) -> Stripe.ClimateOrder
-
-
-
Cancels a Climate order. You can cancel an order within 24 hours of creation. Stripe refunds the reservation
amount_subtotal, but not theamount_feesfor user-triggered cancellations. Frontier might cancel reservations if suppliers fail to deliver. If Frontier cancels the reservation, Stripe provides 90 days advance notice and refunds theamount_total.
-
-
-
await client.climate.order.cancel("order");
-
-
-
order:
string— Unique identifier of the order.
-
request:
Stripe.climate.OrderCancelRequest
-
requestOptions:
Order.RequestOptions
-
-
client.climate.product.list({ ...params }) -> Stripe.ProductListResponse
-
-
-
Lists all available Climate product objects.
-
-
-
await client.climate.product.list();
-
-
-
request:
Stripe.climate.ProductListRequest
-
requestOptions:
Product.RequestOptions
-
-
client.climate.product.retrieve(product, { ...params }) -> Stripe.ClimateProduct
-
-
-
Retrieves the details of a Climate product with the given ID.
-
-
-
await client.climate.product.retrieve("product");
-
-
-
product:
string
-
request:
Stripe.climate.ProductRetrieveRequest
-
requestOptions:
Product.RequestOptions
-
-
client.climate.supplier.list({ ...params }) -> Stripe.SupplierListResponse
-
-
-
Lists all available Climate supplier objects.
-
-
-
await client.climate.supplier.list();
-
-
-
request:
Stripe.climate.SupplierListRequest
-
requestOptions:
Supplier.RequestOptions
-
-
client.climate.supplier.retrieve(supplier, { ...params }) -> Stripe.ClimateSupplier
-
-
-
Retrieves a Climate supplier object.
-
-
-
await client.climate.supplier.retrieve("supplier");
-
-
-
supplier:
string
-
request:
Stripe.climate.SupplierRetrieveRequest
-
requestOptions:
Supplier.RequestOptions
-
-
client.entitlements.activeEntitlement.list({ ...params }) -> Stripe.ActiveEntitlementListResponse
-
-
-
Retrieve a list of active entitlements for a customer
-
-
-
await client.entitlements.activeEntitlement.list({ customer: "customer", });
-
-
-
request:
Stripe.entitlements.ActiveEntitlementListRequest
-
requestOptions:
ActiveEntitlement.RequestOptions
-
-
client.entitlements.activeEntitlement.retrieve(id, { ...params }) -> Stripe.EntitlementsActiveEntitlement
-
-
-
Retrieve an active entitlement
-
-
-
await client.entitlements.activeEntitlement.retrieve("id");
-
-
-
id:
string— The ID of the entitlement.
-
request:
Stripe.entitlements.ActiveEntitlementRetrieveRequest
-
requestOptions:
ActiveEntitlement.RequestOptions
-
-
client.entitlements.feature.list({ ...params }) -> Stripe.FeatureListResponse
-
-
-
Retrieve a list of features
-
-
-
await client.entitlements.feature.list();
-
-
-
request:
Stripe.entitlements.FeatureListRequest
-
requestOptions:
Feature.RequestOptions
-
-
client.entitlements.feature.create({ ...params }) -> Stripe.EntitlementsFeature
-
-
-
Creates a feature
-
-
-
await client.entitlements.feature.create({ lookup_key: "lookup_key", name: "name", });
-
-
-
request:
Stripe.entitlements.FeatureCreateRequest
-
requestOptions:
Feature.RequestOptions
-
-
client.entitlements.feature.retrieve(id, { ...params }) -> Stripe.EntitlementsFeature
-
-
-
Retrieves a feature
-
-
-
await client.entitlements.feature.retrieve("id");
-
-
-
id:
string— The ID of the feature.
-
request:
Stripe.entitlements.FeatureRetrieveRequest
-
requestOptions:
Feature.RequestOptions
-
-
client.entitlements.feature.update(id, { ...params }) -> Stripe.EntitlementsFeature
-
-
-
Update a feature’s metadata or permanently deactivate it.
-
-
-
await client.entitlements.feature.update("id");
-
-
-
id:
string
-
request:
Stripe.entitlements.FeatureUpdateRequest
-
requestOptions:
Feature.RequestOptions
-
-
client.financialConnections.account.list({ ...params }) -> Stripe.AccountListResponse
-
-
-
Returns a list of Financial Connections
Accountobjects.
-
-
-
await client.financialConnections.account.list();
-
-
-
request:
Stripe.financialConnections.AccountListRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.account.retrieve(account, { ...params }) -> Stripe.FinancialConnectionsAccount
-
-
-
Retrieves the details of an Financial Connections
Account.
-
-
-
await client.financialConnections.account.retrieve("account");
-
-
-
account:
string
-
request:
Stripe.financialConnections.AccountRetrieveRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.account.disconnect(account, { ...params }) -> Stripe.FinancialConnectionsAccount
-
-
-
Disables your access to a Financial Connections
Account. You will no longer be able to access data associated with the account (e.g. balances, transactions).
-
-
-
await client.financialConnections.account.disconnect("account");
-
-
-
account:
string
-
request:
Stripe.financialConnections.AccountDisconnectRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.account.listOwners(account, { ...params }) -> Stripe.AccountListOwnersResponse
-
-
-
Lists all owners for a given
Account
-
-
-
await client.financialConnections.account.listOwners("account", { ownership: "ownership", });
-
-
-
account:
string
-
request:
Stripe.financialConnections.AccountListOwnersRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.account.refresh(account, { ...params }) -> Stripe.FinancialConnectionsAccount
-
-
-
Refreshes the data associated with a Financial Connections
Account.
-
-
-
await client.financialConnections.account.refresh("account", { features: ["balance"], });
-
-
-
account:
string
-
request:
Stripe.financialConnections.AccountRefreshRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.account.subscribe(account, { ...params }) -> Stripe.FinancialConnectionsAccount
-
-
-
Subscribes to periodic refreshes of data associated with a Financial Connections
Account.
-
-
-
await client.financialConnections.account.subscribe("account", { features: ["transactions"], });
-
-
-
account:
string
-
request:
Stripe.financialConnections.AccountSubscribeRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.account.unsubscribe(account, { ...params }) -> Stripe.FinancialConnectionsAccount
-
-
-
Unsubscribes from periodic refreshes of data associated with a Financial Connections
Account.
-
-
-
await client.financialConnections.account.unsubscribe("account", { features: ["transactions"], });
-
-
-
account:
string
-
request:
Stripe.financialConnections.AccountUnsubscribeRequest
-
requestOptions:
Account.RequestOptions
-
-
client.financialConnections.session.create({ ...params }) -> Stripe.FinancialConnectionsSession
-
-
-
To launch the Financial Connections authorization flow, create a
Session. The session’sclient_secretcan be used to launch the flow using Stripe.js.
-
-
-
await client.financialConnections.session.create({ account_holder: { type: "account", }, permissions: ["balances"], });
-
-
-
request:
Stripe.financialConnections.SessionCreateRequest
-
requestOptions:
Session.RequestOptions
-
-
client.financialConnections.session.retrieve(session, { ...params }) -> Stripe.FinancialConnectionsSession
-
-
-
Retrieves the details of a Financial Connections
Session
-
-
-
await client.financialConnections.session.retrieve("session");
-
-
-
session:
string
-
request:
Stripe.financialConnections.SessionRetrieveRequest
-
requestOptions:
Session.RequestOptions
-
-
client.financialConnections.transaction.list({ ...params }) -> Stripe.TransactionListResponse
-
-
-
Returns a list of Financial Connections
Transactionobjects.
-
-
-
await client.financialConnections.transaction.list({ account: "account", });
-
-
-
request:
Stripe.financialConnections.TransactionListRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.financialConnections.transaction.retrieve(transaction, { ...params }) -> Stripe.FinancialConnectionsTransaction
-
-
-
Retrieves the details of a Financial Connections
Transaction
-
-
-
await client.financialConnections.transaction.retrieve("transaction");
-
-
-
transaction:
string
-
request:
Stripe.financialConnections.TransactionRetrieveRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.forwarding.request.list({ ...params }) -> Stripe.RequestListResponse
-
-
-
Lists all ForwardingRequest objects.
-
-
-
await client.forwarding.request.list();
-
-
-
request:
Stripe.forwarding.RequestListRequest
-
requestOptions:
Request.RequestOptions
-
-
client.forwarding.request.create({ ...params }) -> Stripe.ForwardingRequest
-
-
-
Creates a ForwardingRequest object.
-
-
-
await client.forwarding.request.create({ payment_method: "payment_method", replacements: ["card_cvc"], url: "url", });
-
-
-
request:
Stripe.forwarding.RequestCreateRequest
-
requestOptions:
Request.RequestOptions
-
-
client.forwarding.request.retrieve(id, { ...params }) -> Stripe.ForwardingRequest
-
-
-
Retrieves a ForwardingRequest object.
-
-
-
await client.forwarding.request.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.forwarding.RequestRetrieveRequest
-
requestOptions:
Request.RequestOptions
-
-
client.identity.verificationReport.list({ ...params }) -> Stripe.VerificationReportListResponse
-
-
-
List all verification reports.
-
-
-
await client.identity.verificationReport.list();
-
-
-
request:
Stripe.identity.VerificationReportListRequest
-
requestOptions:
VerificationReport.RequestOptions
-
-
client.identity.verificationReport.retrieve(report, { ...params }) -> Stripe.IdentityVerificationReport
-
-
-
Retrieves an existing VerificationReport
-
-
-
await client.identity.verificationReport.retrieve("report");
-
-
-
report:
string
-
request:
Stripe.identity.VerificationReportRetrieveRequest
-
requestOptions:
VerificationReport.RequestOptions
-
-
client.identity.verificationSession.list({ ...params }) -> Stripe.VerificationSessionListResponse
-
-
-
Returns a list of VerificationSessions
-
-
-
await client.identity.verificationSession.list();
-
-
-
request:
Stripe.identity.VerificationSessionListRequest
-
requestOptions:
VerificationSession.RequestOptions
-
-
client.identity.verificationSession.create({ ...params }) -> Stripe.IdentityVerificationSession
-
-
-
Creates a VerificationSession object.
After the VerificationSession is created, display a verification modal using the session
client_secretor send your users to the session’surl.If your API key is in test mode, verification checks won’t actually process, though everything else will occur as if in live mode.
Related guide: Verify your users’ identity documents
-
-
-
await client.identity.verificationSession.create();
-
-
-
request:
Stripe.identity.VerificationSessionCreateRequest
-
requestOptions:
VerificationSession.RequestOptions
-
-
client.identity.verificationSession.retrieve(session, { ...params }) -> Stripe.IdentityVerificationSession
-
-
-
Retrieves the details of a VerificationSession that was previously created.
When the session status is
requires_input, you can use this method to retrieve a validclient_secretorurlto allow re-submission.
-
-
-
await client.identity.verificationSession.retrieve("session");
-
-
-
session:
string
-
request:
Stripe.identity.VerificationSessionRetrieveRequest
-
requestOptions:
VerificationSession.RequestOptions
-
-
client.identity.verificationSession.update(session, { ...params }) -> Stripe.IdentityVerificationSession
-
-
-
Updates a VerificationSession object.
When the session status is
requires_input, you can use this method to update the verification check and options.
-
-
-
await client.identity.verificationSession.update("session");
-
-
-
session:
string
-
request:
Stripe.identity.VerificationSessionUpdateRequest
-
requestOptions:
VerificationSession.RequestOptions
-
-
client.identity.verificationSession.cancel(session, { ...params }) -> Stripe.IdentityVerificationSession
-
-
-
A VerificationSession object can be canceled when it is in
requires_inputstatus.Once canceled, future submission attempts are disabled. This cannot be undone. Learn more.
-
-
-
await client.identity.verificationSession.cancel("session");
-
-
-
session:
string
-
request:
Stripe.identity.VerificationSessionCancelRequest
-
requestOptions:
VerificationSession.RequestOptions
-
-
client.identity.verificationSession.redact(session, { ...params }) -> Stripe.IdentityVerificationSession
-
-
-
Redact a VerificationSession to remove all collected information from Stripe. This will redact the VerificationSession and all objects related to it, including VerificationReports, Events, request logs, etc.
A VerificationSession object can be redacted when it is in
requires_inputorverifiedstatus. Redacting a VerificationSession inrequires_actionstate will automatically cancel it.The redaction process may take up to four days. When the redaction process is in progress, the VerificationSession’s
redaction.statusfield will be set toprocessing; when the process is finished, it will change toredactedand anidentity.verification_session.redactedevent will be emitted.Redaction is irreversible. Redacted objects are still accessible in the Stripe API, but all the fields that contain personal data will be replaced by the string
[redacted]or a similar placeholder. Themetadatafield will also be erased. Redacted objects cannot be updated or used for any purpose.
-
-
-
await client.identity.verificationSession.redact("session");
-
-
-
session:
string
-
request:
Stripe.identity.VerificationSessionRedactRequest
-
requestOptions:
VerificationSession.RequestOptions
-
-
client.issuing.authorization.list({ ...params }) -> Stripe.AuthorizationListResponse
-
-
-
Returns a list of Issuing
Authorizationobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.authorization.list();
-
-
-
request:
Stripe.issuing.AuthorizationListRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.retrieve(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Retrieves an Issuing
Authorizationobject.
-
-
-
await client.issuing.authorization.retrieve("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationRetrieveRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.update(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Updates the specified Issuing
Authorizationobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.issuing.authorization.update("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationUpdateRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.approve(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
[Deprecated] Approves a pending Issuing
Authorizationobject. This request should be made within the timeout window of the real-time authorization flow. This method is deprecated. Instead, respond directly to the webhook request to approve an authorization.
-
-
-
await client.issuing.authorization.approve("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationApproveRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.decline(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
[Deprecated] Declines a pending Issuing
Authorizationobject. This request should be made within the timeout window of the real time authorization flow. This method is deprecated. Instead, respond directly to the webhook request to decline an authorization.
-
-
-
await client.issuing.authorization.decline("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationDeclineRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.create({ ...params }) -> Stripe.IssuingAuthorization
-
-
-
Create a test-mode authorization.
-
-
-
await client.issuing.authorization.create({ card: "card", });
-
-
-
request:
Stripe.issuing.AuthorizationCreateRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.capture(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Capture a test-mode authorization.
-
-
-
await client.issuing.authorization.capture("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationCaptureRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.expire(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Expire a test-mode Authorization.
-
-
-
await client.issuing.authorization.expire("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationExpireRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.finalizeAmount(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Finalize the amount on an Authorization prior to capture, when the initial authorization was for an estimated amount.
-
-
-
await client.issuing.authorization.finalizeAmount("authorization", { final_amount: 1, });
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationFinalizeAmountRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.respond(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Respond to a fraud challenge on a testmode Issuing authorization, simulating either a confirmation of fraud or a correction of legitimacy.
-
-
-
await client.issuing.authorization.respond("authorization", { confirmed: true, });
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationRespondRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.increment(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Increment a test-mode Authorization.
-
-
-
await client.issuing.authorization.increment("authorization", { increment_amount: 1, });
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationIncrementRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.authorization.reverse(authorization, { ...params }) -> Stripe.IssuingAuthorization
-
-
-
Reverse a test-mode Authorization.
-
-
-
await client.issuing.authorization.reverse("authorization");
-
-
-
authorization:
string
-
request:
Stripe.issuing.AuthorizationReverseRequest
-
requestOptions:
Authorization.RequestOptions
-
-
client.issuing.cardholder.list({ ...params }) -> Stripe.CardholderListResponse
-
-
-
Returns a list of Issuing
Cardholderobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.cardholder.list();
-
-
-
request:
Stripe.issuing.CardholderListRequest
-
requestOptions:
Cardholder.RequestOptions
-
-
client.issuing.cardholder.create({ ...params }) -> Stripe.IssuingCardholder
-
-
-
Creates a new Issuing
Cardholderobject that can be issued cards.
-
-
-
await client.issuing.cardholder.create({ billing: { address: { city: "city", country: "country", line1: "line1", postal_code: "postal_code", }, }, name: "name", });
-
-
-
request:
Stripe.issuing.CardholderCreateRequest
-
requestOptions:
Cardholder.RequestOptions
-
-
client.issuing.cardholder.retrieve(cardholder, { ...params }) -> Stripe.IssuingCardholder
-
-
-
Retrieves an Issuing
Cardholderobject.
-
-
-
await client.issuing.cardholder.retrieve("cardholder");
-
-
-
cardholder:
string
-
request:
Stripe.issuing.CardholderRetrieveRequest
-
requestOptions:
Cardholder.RequestOptions
-
-
client.issuing.cardholder.update(cardholder, { ...params }) -> Stripe.IssuingCardholder
-
-
-
Updates the specified Issuing
Cardholderobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.issuing.cardholder.update("cardholder");
-
-
-
cardholder:
string
-
request:
Stripe.issuing.CardholderUpdateRequest
-
requestOptions:
Cardholder.RequestOptions
-
-
client.issuing.card.list({ ...params }) -> Stripe.CardListResponse
-
-
-
Returns a list of Issuing
Cardobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.card.list();
-
-
-
request:
Stripe.issuing.CardListRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.create({ ...params }) -> Stripe.IssuingCard
-
-
-
Creates an Issuing
Cardobject.
-
-
-
await client.issuing.card.create({ currency: "currency", type: "physical", });
-
-
-
request:
Stripe.issuing.CardCreateRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.retrieve(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Retrieves an Issuing
Cardobject.
-
-
-
await client.issuing.card.retrieve("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardRetrieveRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.update(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Updates the specified Issuing
Cardobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.issuing.card.update("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardUpdateRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.deliverCard(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Updates the shipping status of the specified Issuing
Cardobject todelivered.
-
-
-
await client.issuing.card.deliverCard("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardDeliverCardRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.failCard(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Updates the shipping status of the specified Issuing
Cardobject tofailure.
-
-
-
await client.issuing.card.failCard("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardFailCardRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.returnCard(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Updates the shipping status of the specified Issuing
Cardobject toreturned.
-
-
-
await client.issuing.card.returnCard("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardReturnCardRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.shipCard(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Updates the shipping status of the specified Issuing
Cardobject toshipped.
-
-
-
await client.issuing.card.shipCard("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardShipCardRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.card.submitCard(card, { ...params }) -> Stripe.IssuingCard
-
-
-
Updates the shipping status of the specified Issuing
Cardobject tosubmitted. This method requires Stripe Version ‘2024-09-30.acacia’ or later.
-
-
-
await client.issuing.card.submitCard("card");
-
-
-
card:
string
-
request:
Stripe.issuing.CardSubmitCardRequest
-
requestOptions:
Card.RequestOptions
-
-
client.issuing.dispute.list({ ...params }) -> Stripe.DisputeListResponse
-
-
-
Returns a list of Issuing
Disputeobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.dispute.list();
-
-
-
request:
Stripe.issuing.DisputeListRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.issuing.dispute.create({ ...params }) -> Stripe.IssuingDispute
-
-
-
Creates an Issuing
Disputeobject. Individual pieces of evidence within theevidenceobject are optional at this point. Stripe only validates that required evidence is present during submission. Refer to Dispute reasons and evidence for more details about evidence requirements.
-
-
-
await client.issuing.dispute.create();
-
-
-
request:
Stripe.issuing.DisputeCreateRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.issuing.dispute.retrieve(dispute, { ...params }) -> Stripe.IssuingDispute
-
-
-
Retrieves an Issuing
Disputeobject.
-
-
-
await client.issuing.dispute.retrieve("dispute");
-
-
-
dispute:
string
-
request:
Stripe.issuing.DisputeRetrieveRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.issuing.dispute.update(dispute, { ...params }) -> Stripe.IssuingDispute
-
-
-
Updates the specified Issuing
Disputeobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged. Properties on theevidenceobject can be unset by passing in an empty string.
-
-
-
await client.issuing.dispute.update("dispute");
-
-
-
dispute:
string
-
request:
Stripe.issuing.DisputeUpdateRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.issuing.dispute.submit(dispute, { ...params }) -> Stripe.IssuingDispute
-
-
-
Submits an Issuing
Disputeto the card network. Stripe validates that all evidence fields required for the dispute’s reason are present. For more details, see Dispute reasons and evidence.
-
-
-
await client.issuing.dispute.submit("dispute");
-
-
-
dispute:
string
-
request:
Stripe.issuing.DisputeSubmitRequest
-
requestOptions:
Dispute.RequestOptions
-
-
client.issuing.personalizationDesign.list({ ...params }) -> Stripe.PersonalizationDesignListResponse
-
-
-
Returns a list of personalization design objects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.personalizationDesign.list();
-
-
-
request:
Stripe.issuing.PersonalizationDesignListRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.personalizationDesign.create({ ...params }) -> Stripe.IssuingPersonalizationDesign
-
-
-
Creates a personalization design object.
-
-
-
await client.issuing.personalizationDesign.create({ physical_bundle: "physical_bundle", });
-
-
-
request:
Stripe.issuing.PersonalizationDesignCreateRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.personalizationDesign.retrieve(personalizationDesign, { ...params }) -> Stripe.IssuingPersonalizationDesign
-
-
-
Retrieves a personalization design object.
-
-
-
await client.issuing.personalizationDesign.retrieve("personalization_design");
-
-
-
personalizationDesign:
string
-
request:
Stripe.issuing.PersonalizationDesignRetrieveRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.personalizationDesign.update(personalizationDesign, { ...params }) -> Stripe.IssuingPersonalizationDesign
-
-
-
Updates a card personalization object.
-
-
-
await client.issuing.personalizationDesign.update("personalization_design");
-
-
-
personalizationDesign:
string
-
request:
Stripe.issuing.PersonalizationDesignUpdateRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.personalizationDesign.activate(personalizationDesign, { ...params }) -> Stripe.IssuingPersonalizationDesign
-
-
-
Updates the
statusof the specified testmode personalization design object toactive.
-
-
-
await client.issuing.personalizationDesign.activate("personalization_design");
-
-
-
personalizationDesign:
string
-
request:
Stripe.issuing.PersonalizationDesignActivateRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.personalizationDesign.deactivate(personalizationDesign, { ...params }) -> Stripe.IssuingPersonalizationDesign
-
-
-
Updates the
statusof the specified testmode personalization design object toinactive.
-
-
-
await client.issuing.personalizationDesign.deactivate("personalization_design");
-
-
-
personalizationDesign:
string
-
request:
Stripe.issuing.PersonalizationDesignDeactivateRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.personalizationDesign.reject(personalizationDesign, { ...params }) -> Stripe.IssuingPersonalizationDesign
-
-
-
Updates the
statusof the specified testmode personalization design object torejected.
-
-
-
await client.issuing.personalizationDesign.reject("personalization_design", { rejection_reasons: {}, });
-
-
-
personalizationDesign:
string
-
request:
Stripe.issuing.PersonalizationDesignRejectRequest
-
requestOptions:
PersonalizationDesign.RequestOptions
-
-
client.issuing.physicalBundle.list({ ...params }) -> Stripe.PhysicalBundleListResponse
-
-
-
Returns a list of physical bundle objects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.physicalBundle.list();
-
-
-
request:
Stripe.issuing.PhysicalBundleListRequest
-
requestOptions:
PhysicalBundle.RequestOptions
-
-
client.issuing.physicalBundle.retrieve(physicalBundle, { ...params }) -> Stripe.IssuingPhysicalBundle
-
-
-
Retrieves a physical bundle object.
-
-
-
await client.issuing.physicalBundle.retrieve("physical_bundle");
-
-
-
physicalBundle:
string
-
request:
Stripe.issuing.PhysicalBundleRetrieveRequest
-
requestOptions:
PhysicalBundle.RequestOptions
-
-
client.issuing.token.list({ ...params }) -> Stripe.TokenListResponse
-
-
-
Lists all Issuing
Tokenobjects for a given card.
-
-
-
await client.issuing.token.list({ card: "card", });
-
-
-
request:
Stripe.issuing.TokenListRequest
-
requestOptions:
Token.RequestOptions
-
-
client.issuing.token.retrieve(token, { ...params }) -> Stripe.IssuingToken
-
-
-
Retrieves an Issuing
Tokenobject.
-
-
-
await client.issuing.token.retrieve("token");
-
-
-
token:
string
-
request:
Stripe.issuing.TokenRetrieveRequest
-
requestOptions:
Token.RequestOptions
-
-
client.issuing.token.update(token, { ...params }) -> Stripe.IssuingToken
-
-
-
Attempts to update the specified Issuing
Tokenobject to the status specified.
-
-
-
await client.issuing.token.update("token", { status: "active", });
-
-
-
token:
string
-
request:
Stripe.issuing.TokenUpdateRequest
-
requestOptions:
Token.RequestOptions
-
-
client.issuing.transaction.list({ ...params }) -> Stripe.TransactionListResponse
-
-
-
Returns a list of Issuing
Transactionobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.issuing.transaction.list();
-
-
-
request:
Stripe.issuing.TransactionListRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.issuing.transaction.retrieve(transaction, { ...params }) -> Stripe.IssuingTransaction
-
-
-
Retrieves an Issuing
Transactionobject.
-
-
-
await client.issuing.transaction.retrieve("transaction");
-
-
-
transaction:
string
-
request:
Stripe.issuing.TransactionRetrieveRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.issuing.transaction.update(transaction, { ...params }) -> Stripe.IssuingTransaction
-
-
-
Updates the specified Issuing
Transactionobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.issuing.transaction.update("transaction");
-
-
-
transaction:
string
-
request:
Stripe.issuing.TransactionUpdateRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.issuing.transaction.createForceCapture({ ...params }) -> Stripe.IssuingTransaction
-
-
-
Allows the user to capture an arbitrary amount, also known as a forced capture.
-
-
-
await client.issuing.transaction.createForceCapture({ amount: 1, card: "card", });
-
-
-
request:
Stripe.issuing.TransactionCreateForceCaptureRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.issuing.transaction.createUnlinkedRefund({ ...params }) -> Stripe.IssuingTransaction
-
-
-
Allows the user to refund an arbitrary amount, also known as a unlinked refund.
-
-
-
await client.issuing.transaction.createUnlinkedRefund({ amount: 1, card: "card", });
-
-
-
request:
Stripe.issuing.TransactionCreateUnlinkedRefundRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.issuing.transaction.refund(transaction, { ...params }) -> Stripe.IssuingTransaction
-
-
-
Refund a test-mode Transaction.
-
-
-
await client.issuing.transaction.refund("transaction");
-
-
-
transaction:
string
-
request:
Stripe.issuing.TransactionRefundRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.radar.earlyFraudWarning.list({ ...params }) -> Stripe.EarlyFraudWarningListResponse
-
-
-
Returns a list of early fraud warnings.
-
-
-
await client.radar.earlyFraudWarning.list();
-
-
-
request:
Stripe.radar.EarlyFraudWarningListRequest
-
requestOptions:
EarlyFraudWarning.RequestOptions
-
-
client.radar.earlyFraudWarning.retrieve(earlyFraudWarning, { ...params }) -> Stripe.RadarEarlyFraudWarning
-
-
-
Retrieves the details of an early fraud warning that has previously been created.
Please refer to the early fraud warning object reference for more details.
-
-
-
await client.radar.earlyFraudWarning.retrieve("early_fraud_warning");
-
-
-
earlyFraudWarning:
string
-
request:
Stripe.radar.EarlyFraudWarningRetrieveRequest
-
requestOptions:
EarlyFraudWarning.RequestOptions
-
-
client.radar.valueListItem.list({ ...params }) -> Stripe.ValueListItemListResponse
-
-
-
Returns a list of
ValueListItemobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.radar.valueListItem.list({ value_list: "value_list", });
-
-
-
request:
Stripe.radar.ValueListItemListRequest
-
requestOptions:
ValueListItem.RequestOptions
-
-
client.radar.valueListItem.create({ ...params }) -> Stripe.RadarValueListItem
-
-
-
Creates a new
ValueListItemobject, which is added to the specified parent value list.
-
-
-
await client.radar.valueListItem.create({ value: "value", value_list: "value_list", });
-
-
-
request:
Stripe.radar.ValueListItemCreateRequest
-
requestOptions:
ValueListItem.RequestOptions
-
-
client.radar.valueListItem.retrieve(item, { ...params }) -> Stripe.RadarValueListItem
-
-
-
Retrieves a
ValueListItemobject.
-
-
-
await client.radar.valueListItem.retrieve("item");
-
-
-
item:
string
-
request:
Stripe.radar.ValueListItemRetrieveRequest
-
requestOptions:
ValueListItem.RequestOptions
-
-
client.radar.valueListItem.delete(item, { ...params }) -> Stripe.DeletedRadarValueListItem
-
-
-
Deletes a
ValueListItemobject, removing it from its parent value list.
-
-
-
await client.radar.valueListItem.delete("item");
-
-
-
item:
string
-
request:
Stripe.radar.ValueListItemDeleteRequest
-
requestOptions:
ValueListItem.RequestOptions
-
-
client.radar.valueList.list({ ...params }) -> Stripe.ValueListListResponse
-
-
-
Returns a list of
ValueListobjects. The objects are sorted in descending order by creation date, with the most recently created object appearing first.
-
-
-
await client.radar.valueList.list();
-
-
-
request:
Stripe.radar.ValueListListRequest
-
requestOptions:
ValueList.RequestOptions
-
-
client.radar.valueList.create({ ...params }) -> Stripe.RadarValueList
-
-
-
Creates a new
ValueListobject, which can then be referenced in rules.
-
-
-
await client.radar.valueList.create({ alias: "alias", name: "name", });
-
-
-
request:
Stripe.radar.ValueListCreateRequest
-
requestOptions:
ValueList.RequestOptions
-
-
client.radar.valueList.retrieve(valueList, { ...params }) -> Stripe.RadarValueList
-
-
-
Retrieves a
ValueListobject.
-
-
-
await client.radar.valueList.retrieve("value_list");
-
-
-
valueList:
string
-
request:
Stripe.radar.ValueListRetrieveRequest
-
requestOptions:
ValueList.RequestOptions
-
-
client.radar.valueList.update(valueList, { ...params }) -> Stripe.RadarValueList
-
-
-
Updates a
ValueListobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged. Note thatitem_typeis immutable.
-
-
-
await client.radar.valueList.update("value_list");
-
-
-
valueList:
string
-
request:
Stripe.radar.ValueListUpdateRequest
-
requestOptions:
ValueList.RequestOptions
-
-
client.radar.valueList.delete(valueList, { ...params }) -> Stripe.DeletedRadarValueList
-
-
-
Deletes a
ValueListobject, also deleting any items contained within the value list. To be deleted, a value list must not be referenced in any rules.
-
-
-
await client.radar.valueList.delete("value_list");
-
-
-
valueList:
string
-
request:
Stripe.radar.ValueListDeleteRequest
-
requestOptions:
ValueList.RequestOptions
-
-
client.reporting.reportRun.list({ ...params }) -> Stripe.ReportRunListResponse
-
-
-
Returns a list of Report Runs, with the most recent appearing first.
-
-
-
await client.reporting.reportRun.list();
-
-
-
request:
Stripe.reporting.ReportRunListRequest
-
requestOptions:
ReportRun.RequestOptions
-
-
client.reporting.reportRun.create({ ...params }) -> Stripe.ReportingReportRun
-
-
-
Creates a new object and begin running the report. (Certain report types require a live-mode API key.)
-
-
-
await client.reporting.reportRun.create({ report_type: "report_type", });
-
-
-
request:
Stripe.reporting.ReportRunCreateRequest
-
requestOptions:
ReportRun.RequestOptions
-
-
client.reporting.reportRun.retrieve(reportRun, { ...params }) -> Stripe.ReportingReportRun
-
-
-
Retrieves the details of an existing Report Run.
-
-
-
await client.reporting.reportRun.retrieve("report_run");
-
-
-
reportRun:
string
-
request:
Stripe.reporting.ReportRunRetrieveRequest
-
requestOptions:
ReportRun.RequestOptions
-
-
client.reporting.reportType.list({ ...params }) -> Stripe.ReportTypeListResponse
-
-
-
Returns a full list of Report Types.
-
-
-
await client.reporting.reportType.list();
-
-
-
request:
Stripe.reporting.ReportTypeListRequest
-
requestOptions:
ReportType.RequestOptions
-
-
client.reporting.reportType.retrieve(reportType, { ...params }) -> Stripe.ReportingReportType
-
-
-
Retrieves the details of a Report Type. (Certain report types require a live-mode API key.)
-
-
-
await client.reporting.reportType.retrieve("report_type");
-
-
-
reportType:
string
-
request:
Stripe.reporting.ReportTypeRetrieveRequest
-
requestOptions:
ReportType.RequestOptions
-
-
client.tax.calculation.create({ ...params }) -> Stripe.TaxCalculation
-
-
-
Calculates tax based on the input and returns a Tax
Calculationobject.
-
-
-
await client.tax.calculation.create({ currency: "currency", line_items: [ { amount: 1, }, ], });
-
-
-
request:
Stripe.tax.CalculationCreateRequest
-
requestOptions:
Calculation.RequestOptions
-
-
client.tax.calculation.retrieve(calculation, { ...params }) -> Stripe.TaxCalculation
-
-
-
Retrieves a Tax
Calculationobject, if the calculation hasn’t expired.
-
-
-
await client.tax.calculation.retrieve("calculation");
-
-
-
calculation:
string
-
request:
Stripe.tax.CalculationRetrieveRequest
-
requestOptions:
Calculation.RequestOptions
-
-
client.tax.calculation.listLineItems(calculation, { ...params }) -> Stripe.CalculationListLineItemsResponse
-
-
-
Retrieves the line items of a tax calculation as a collection, if the calculation hasn’t expired.
-
-
-
await client.tax.calculation.listLineItems("calculation");
-
-
-
calculation:
string
-
request:
Stripe.tax.CalculationListLineItemsRequest
-
requestOptions:
Calculation.RequestOptions
-
-
client.tax.registration.list({ ...params }) -> Stripe.RegistrationListResponse
-
-
-
Returns a list of Tax
Registrationobjects.
-
-
-
await client.tax.registration.list();
-
-
-
request:
Stripe.tax.RegistrationListRequest
-
requestOptions:
Registration.RequestOptions
-
-
client.tax.registration.create({ ...params }) -> Stripe.TaxRegistration
-
-
-
Creates a new Tax
Registrationobject.
-
-
-
await client.tax.registration.create({ active_from: "now", country: "country", country_options: {}, });
-
-
-
request:
Stripe.tax.RegistrationCreateRequest
-
requestOptions:
Registration.RequestOptions
-
-
client.tax.registration.retrieve(id, { ...params }) -> Stripe.TaxRegistration
-
-
-
Returns a Tax
Registrationobject.
-
-
-
await client.tax.registration.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.tax.RegistrationRetrieveRequest
-
requestOptions:
Registration.RequestOptions
-
-
client.tax.registration.update(id, { ...params }) -> Stripe.TaxRegistration
-
-
-
Updates an existing Tax
Registrationobject.A registration cannot be deleted after it has been created. If you wish to end a registration you may do so by setting
expires_at.
-
-
-
await client.tax.registration.update("id");
-
-
-
id:
string
-
request:
Stripe.tax.RegistrationUpdateRequest
-
requestOptions:
Registration.RequestOptions
-
-
client.tax.settings.retrieve({ ...params }) -> Stripe.TaxSettings
-
-
-
Retrieves Tax
Settingsfor a merchant.
-
-
-
await client.tax.settings.retrieve();
-
-
-
request:
Stripe.tax.SettingsRetrieveRequest
-
requestOptions:
Settings.RequestOptions
-
-
client.tax.settings.update({ ...params }) -> Stripe.TaxSettings
-
-
-
Updates Tax
Settingsparameters used in tax calculations. All parameters are editable but none can be removed once set.
-
-
-
await client.tax.settings.update();
-
-
-
request:
Stripe.tax.SettingsUpdateRequest
-
requestOptions:
Settings.RequestOptions
-
-
client.tax.transaction.createFromCalculation({ ...params }) -> Stripe.TaxTransaction
-
-
-
Creates a Tax Transaction from a calculation, if that calculation hasn’t expired. Calculations expire after 90 days.
-
-
-
await client.tax.transaction.createFromCalculation({ calculation: "calculation", reference: "reference", });
-
-
-
request:
Stripe.tax.TransactionCreateFromCalculationRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.tax.transaction.createReversal({ ...params }) -> Stripe.TaxTransaction
-
-
-
Partially or fully reverses a previously created
Transaction.
-
-
-
await client.tax.transaction.createReversal({ mode: "full", original_transaction: "original_transaction", reference: "reference", });
-
-
-
request:
Stripe.tax.TransactionCreateReversalRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.tax.transaction.retrieve(transaction, { ...params }) -> Stripe.TaxTransaction
-
-
-
Retrieves a Tax
Transactionobject.
-
-
-
await client.tax.transaction.retrieve("transaction");
-
-
-
transaction:
string
-
request:
Stripe.tax.TransactionRetrieveRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.tax.transaction.listLineItems(transaction, { ...params }) -> Stripe.TransactionListLineItemsResponse
-
-
-
Retrieves the line items of a committed standalone transaction as a collection.
-
-
-
await client.tax.transaction.listLineItems("transaction");
-
-
-
transaction:
string
-
request:
Stripe.tax.TransactionListLineItemsRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.terminal.configuration.list({ ...params }) -> Stripe.ConfigurationListResponse
-
-
-
Returns a list of
Configurationobjects.
-
-
-
await client.terminal.configuration.list();
-
-
-
request:
Stripe.terminal.ConfigurationListRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.terminal.configuration.create({ ...params }) -> Stripe.TerminalConfiguration
-
-
-
Creates a new
Configurationobject.
-
-
-
await client.terminal.configuration.create();
-
-
-
request:
Stripe.terminal.ConfigurationCreateRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.terminal.configuration.retrieve(configuration, { ...params }) -> Stripe.ConfigurationRetrieveResponse
-
-
-
Retrieves a
Configurationobject.
-
-
-
await client.terminal.configuration.retrieve("configuration");
-
-
-
configuration:
string
-
request:
Stripe.terminal.ConfigurationRetrieveRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.terminal.configuration.update(configuration, { ...params }) -> Stripe.ConfigurationUpdateResponse
-
-
-
Updates a new
Configurationobject.
-
-
-
await client.terminal.configuration.update("configuration");
-
-
-
configuration:
string
-
request:
Stripe.terminal.ConfigurationUpdateRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.terminal.configuration.delete(configuration, { ...params }) -> Stripe.DeletedTerminalConfiguration
-
-
-
Deletes a
Configurationobject.
-
-
-
await client.terminal.configuration.delete("configuration");
-
-
-
configuration:
string
-
request:
Stripe.terminal.ConfigurationDeleteRequest
-
requestOptions:
Configuration.RequestOptions
-
-
client.terminal.connectionToken.create({ ...params }) -> Stripe.TerminalConnectionToken
-
-
-
To connect to a reader the Stripe Terminal SDK needs to retrieve a short-lived connection token from Stripe, proxied through your server. On your backend, add an endpoint that creates and returns a connection token.
-
-
-
await client.terminal.connectionToken.create();
-
-
-
request:
Stripe.terminal.ConnectionTokenCreateRequest
-
requestOptions:
ConnectionToken.RequestOptions
-
-
client.terminal.location.list({ ...params }) -> Stripe.LocationListResponse
-
-
-
Returns a list of
Locationobjects.
-
-
-
await client.terminal.location.list();
-
-
-
request:
Stripe.terminal.LocationListRequest
-
requestOptions:
Location.RequestOptions
-
-
client.terminal.location.create({ ...params }) -> Stripe.TerminalLocation
-
-
-
Creates a new
Locationobject. For further details, including which address fields are required in each country, see the Manage locations guide.
-
-
-
await client.terminal.location.create({ address: { country: "country", }, display_name: "display_name", });
-
-
-
request:
Stripe.terminal.LocationCreateRequest
-
requestOptions:
Location.RequestOptions
-
-
client.terminal.location.retrieve(location, { ...params }) -> Stripe.LocationRetrieveResponse
-
-
-
Retrieves a
Locationobject.
-
-
-
await client.terminal.location.retrieve("location");
-
-
-
location:
string
-
request:
Stripe.terminal.LocationRetrieveRequest
-
requestOptions:
Location.RequestOptions
-
-
client.terminal.location.update(location, { ...params }) -> Stripe.LocationUpdateResponse
-
-
-
Updates a
Locationobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.terminal.location.update("location");
-
-
-
location:
string
-
request:
Stripe.terminal.LocationUpdateRequest
-
requestOptions:
Location.RequestOptions
-
-
client.terminal.location.delete(location, { ...params }) -> Stripe.DeletedTerminalLocation
-
-
-
Deletes a
Locationobject.
-
-
-
await client.terminal.location.delete("location");
-
-
-
location:
string
-
request:
Stripe.terminal.LocationDeleteRequest
-
requestOptions:
Location.RequestOptions
-
-
client.terminal.reader.list({ ...params }) -> Stripe.ReaderListResponse
-
-
-
Returns a list of
Readerobjects.
-
-
-
await client.terminal.reader.list();
-
-
-
request:
Stripe.terminal.ReaderListRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.create({ ...params }) -> Stripe.TerminalReader
-
-
-
Creates a new
Readerobject.
-
-
-
await client.terminal.reader.create({ registration_code: "registration_code", });
-
-
-
request:
Stripe.terminal.ReaderCreateRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.retrieve(reader, { ...params }) -> Stripe.ReaderRetrieveResponse
-
-
-
Retrieves a
Readerobject.
-
-
-
await client.terminal.reader.retrieve("reader");
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderRetrieveRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.update(reader, { ...params }) -> Stripe.ReaderUpdateResponse
-
-
-
Updates a
Readerobject by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
-
-
-
await client.terminal.reader.update("reader");
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderUpdateRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.delete(reader, { ...params }) -> Stripe.DeletedTerminalReader
-
-
-
Deletes a
Readerobject.
-
-
-
await client.terminal.reader.delete("reader");
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderDeleteRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.cancelAction(reader, { ...params }) -> Stripe.TerminalReader
-
-
-
Cancels the current reader action.
-
-
-
await client.terminal.reader.cancelAction("reader");
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderCancelActionRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.processPaymentIntent(reader, { ...params }) -> Stripe.TerminalReader
-
-
-
Initiates a payment flow on a Reader.
-
-
-
await client.terminal.reader.processPaymentIntent("reader", { payment_intent: "payment_intent", });
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderProcessPaymentIntentRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.processSetupIntent(reader, { ...params }) -> Stripe.TerminalReader
-
-
-
Initiates a setup intent flow on a Reader.
-
-
-
await client.terminal.reader.processSetupIntent("reader", { allow_redisplay: "always", setup_intent: "setup_intent", });
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderProcessSetupIntentRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.refundPayment(reader, { ...params }) -> Stripe.TerminalReader
-
-
-
Initiates a refund on a Reader
-
-
-
await client.terminal.reader.refundPayment("reader");
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderRefundPaymentRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.setReaderDisplay(reader, { ...params }) -> Stripe.TerminalReader
-
-
-
Sets reader display to show cart details.
-
-
-
await client.terminal.reader.setReaderDisplay("reader", {});
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderSetReaderDisplayRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.terminal.reader.presentPaymentMethod(reader, { ...params }) -> Stripe.TerminalReader
-
-
-
Presents a payment method on a simulated reader. Can be used to simulate accepting a payment, saving a card or refunding a transaction.
-
-
-
await client.terminal.reader.presentPaymentMethod("reader");
-
-
-
reader:
string
-
request:
Stripe.terminal.ReaderPresentPaymentMethodRequest
-
requestOptions:
Reader.RequestOptions
-
-
client.testHelpers.testClock.list({ ...params }) -> Stripe.TestClockListResponse
-
-
-
Returns a list of your test clocks.
-
-
-
await client.testHelpers.testClock.list();
-
-
-
request:
Stripe.testHelpers.TestClockListRequest
-
requestOptions:
TestClock.RequestOptions
-
-
client.testHelpers.testClock.create({ ...params }) -> Stripe.TestHelpersTestClock
-
-
-
Creates a new test clock that can be attached to new customers and quotes.
-
-
-
await client.testHelpers.testClock.create({ frozen_time: 1, });
-
-
-
request:
Stripe.testHelpers.TestClockCreateRequest
-
requestOptions:
TestClock.RequestOptions
-
-
client.testHelpers.testClock.retrieve(testClock, { ...params }) -> Stripe.TestHelpersTestClock
-
-
-
Retrieves a test clock.
-
-
-
await client.testHelpers.testClock.retrieve("test_clock");
-
-
-
testClock:
string
-
request:
Stripe.testHelpers.TestClockRetrieveRequest
-
requestOptions:
TestClock.RequestOptions
-
-
client.testHelpers.testClock.delete(testClock, { ...params }) -> Stripe.DeletedTestHelpersTestClock
-
-
-
Deletes a test clock.
-
-
-
await client.testHelpers.testClock.delete("test_clock");
-
-
-
testClock:
string
-
request:
Stripe.testHelpers.TestClockDeleteRequest
-
requestOptions:
TestClock.RequestOptions
-
-
client.testHelpers.testClock.advance(testClock, { ...params }) -> Stripe.TestHelpersTestClock
-
-
-
Starts advancing a test clock to a specified time in the future. Advancement is done when status changes to
Ready.
-
-
-
await client.testHelpers.testClock.advance("test_clock", { frozen_time: 1, });
-
-
-
testClock:
string
-
request:
Stripe.testHelpers.TestClockAdvanceRequest
-
requestOptions:
TestClock.RequestOptions
-
-
client.treasury.inboundTransfer.fail(id, { ...params }) -> Stripe.TreasuryInboundTransfer
-
-
-
Transitions a test mode created InboundTransfer to the
failedstatus. The InboundTransfer must already be in theprocessingstate.
-
-
-
await client.treasury.inboundTransfer.fail("id");
-
-
-
id:
string
-
request:
Stripe.treasury.InboundTransferFailRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.inboundTransfer.returnInboundTransfer(id, { ...params }) -> Stripe.TreasuryInboundTransfer
-
-
-
Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the
succeededstate.
-
-
-
await client.treasury.inboundTransfer.returnInboundTransfer("id");
-
-
-
id:
string
-
request:
Stripe.treasury.InboundTransferReturnInboundTransferRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.inboundTransfer.succeed(id, { ...params }) -> Stripe.TreasuryInboundTransfer
-
-
-
Transitions a test mode created InboundTransfer to the
succeededstatus. The InboundTransfer must already be in theprocessingstate.
-
-
-
await client.treasury.inboundTransfer.succeed("id");
-
-
-
id:
string
-
request:
Stripe.treasury.InboundTransferSucceedRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.inboundTransfer.list({ ...params }) -> Stripe.InboundTransferListResponse
-
-
-
Returns a list of InboundTransfers sent from the specified FinancialAccount.
-
-
-
await client.treasury.inboundTransfer.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.InboundTransferListRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.inboundTransfer.create({ ...params }) -> Stripe.TreasuryInboundTransfer
-
-
-
Creates an InboundTransfer.
-
-
-
await client.treasury.inboundTransfer.create({ amount: 1, currency: "currency", financial_account: "financial_account", origin_payment_method: "origin_payment_method", });
-
-
-
request:
Stripe.treasury.InboundTransferCreateRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.inboundTransfer.retrieve(id, { ...params }) -> Stripe.TreasuryInboundTransfer
-
-
-
Retrieves the details of an existing InboundTransfer.
-
-
-
await client.treasury.inboundTransfer.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.treasury.InboundTransferRetrieveRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.inboundTransfer.cancel(inboundTransfer, { ...params }) -> Stripe.TreasuryInboundTransfer
-
-
-
Cancels an InboundTransfer.
-
-
-
await client.treasury.inboundTransfer.cancel("inbound_transfer");
-
-
-
inboundTransfer:
string
-
request:
Stripe.treasury.InboundTransferCancelRequest
-
requestOptions:
InboundTransfer.RequestOptions
-
-
client.treasury.outboundPayment.update(id, { ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Updates a test mode created OutboundPayment with tracking details. The OutboundPayment must not be cancelable, and cannot be in the
canceledorfailedstates.
-
-
-
await client.treasury.outboundPayment.update("id", { tracking_details: { type: "ach", }, });
-
-
-
id:
string
-
request:
Stripe.treasury.OutboundPaymentUpdateRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.fail(id, { ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Transitions a test mode created OutboundPayment to the
failedstatus. The OutboundPayment must already be in theprocessingstate.
-
-
-
await client.treasury.outboundPayment.fail("id");
-
-
-
id:
string
-
request:
Stripe.treasury.OutboundPaymentFailRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.post(id, { ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Transitions a test mode created OutboundPayment to the
postedstatus. The OutboundPayment must already be in theprocessingstate.
-
-
-
await client.treasury.outboundPayment.post("id");
-
-
-
id:
string
-
request:
Stripe.treasury.OutboundPaymentPostRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.returnOutboundPayment(id, { ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Transitions a test mode created OutboundPayment to the
returnedstatus. The OutboundPayment must already be in theprocessingstate.
-
-
-
await client.treasury.outboundPayment.returnOutboundPayment("id");
-
-
-
id:
string
-
request:
Stripe.treasury.OutboundPaymentReturnOutboundPaymentRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.list({ ...params }) -> Stripe.OutboundPaymentListResponse
-
-
-
Returns a list of OutboundPayments sent from the specified FinancialAccount.
-
-
-
await client.treasury.outboundPayment.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.OutboundPaymentListRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.create({ ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Creates an OutboundPayment.
-
-
-
await client.treasury.outboundPayment.create({ amount: 1, currency: "currency", financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.OutboundPaymentCreateRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.retrieve(id, { ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Retrieves the details of an existing OutboundPayment by passing the unique OutboundPayment ID from either the OutboundPayment creation request or OutboundPayment list.
-
-
-
await client.treasury.outboundPayment.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.treasury.OutboundPaymentRetrieveRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundPayment.cancel(id, { ...params }) -> Stripe.TreasuryOutboundPayment
-
-
-
Cancel an OutboundPayment.
-
-
-
await client.treasury.outboundPayment.cancel("id");
-
-
-
id:
string
-
request:
Stripe.treasury.OutboundPaymentCancelRequest
-
requestOptions:
OutboundPayment.RequestOptions
-
-
client.treasury.outboundTransfer.update(outboundTransfer, { ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
Updates a test mode created OutboundTransfer with tracking details. The OutboundTransfer must not be cancelable, and cannot be in the
canceledorfailedstates.
-
-
-
await client.treasury.outboundTransfer.update("outbound_transfer", { tracking_details: { type: "ach", }, });
-
-
-
outboundTransfer:
string
-
request:
Stripe.treasury.OutboundTransferUpdateRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.fail(outboundTransfer, { ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
Transitions a test mode created OutboundTransfer to the
failedstatus. The OutboundTransfer must already be in theprocessingstate.
-
-
-
await client.treasury.outboundTransfer.fail("outbound_transfer");
-
-
-
outboundTransfer:
string
-
request:
Stripe.treasury.OutboundTransferFailRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.post(outboundTransfer, { ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
Transitions a test mode created OutboundTransfer to the
postedstatus. The OutboundTransfer must already be in theprocessingstate.
-
-
-
await client.treasury.outboundTransfer.post("outbound_transfer");
-
-
-
outboundTransfer:
string
-
request:
Stripe.treasury.OutboundTransferPostRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.returnOutboundTransfer(outboundTransfer, { ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
Transitions a test mode created OutboundTransfer to the
returnedstatus. The OutboundTransfer must already be in theprocessingstate.
-
-
-
await client.treasury.outboundTransfer.returnOutboundTransfer("outbound_transfer");
-
-
-
outboundTransfer:
string
-
request:
Stripe.treasury.OutboundTransferReturnOutboundTransferRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.list({ ...params }) -> Stripe.OutboundTransferListResponse
-
-
-
Returns a list of OutboundTransfers sent from the specified FinancialAccount.
-
-
-
await client.treasury.outboundTransfer.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.OutboundTransferListRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.create({ ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
Creates an OutboundTransfer.
-
-
-
await client.treasury.outboundTransfer.create({ amount: 1, currency: "currency", financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.OutboundTransferCreateRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.retrieve(outboundTransfer, { ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundTransfer creation request or OutboundTransfer list.
-
-
-
await client.treasury.outboundTransfer.retrieve("outbound_transfer");
-
-
-
outboundTransfer:
string
-
request:
Stripe.treasury.OutboundTransferRetrieveRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.outboundTransfer.cancel(outboundTransfer, { ...params }) -> Stripe.TreasuryOutboundTransfer
-
-
-
An OutboundTransfer can be canceled if the funds have not yet been paid out.
-
-
-
await client.treasury.outboundTransfer.cancel("outbound_transfer");
-
-
-
outboundTransfer:
string
-
request:
Stripe.treasury.OutboundTransferCancelRequest
-
requestOptions:
OutboundTransfer.RequestOptions
-
-
client.treasury.receivedCredit.create({ ...params }) -> Stripe.TreasuryReceivedCredit
-
-
-
Use this endpoint to simulate a test mode ReceivedCredit initiated by a third party. In live mode, you can’t directly create ReceivedCredits initiated by third parties.
-
-
-
await client.treasury.receivedCredit.create({ amount: 1, currency: "currency", financial_account: "financial_account", network: "ach", });
-
-
-
request:
Stripe.treasury.ReceivedCreditCreateRequest
-
requestOptions:
ReceivedCredit.RequestOptions
-
-
client.treasury.receivedCredit.list({ ...params }) -> Stripe.ReceivedCreditListResponse
-
-
-
Returns a list of ReceivedCredits.
-
-
-
await client.treasury.receivedCredit.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.ReceivedCreditListRequest
-
requestOptions:
ReceivedCredit.RequestOptions
-
-
client.treasury.receivedCredit.retrieve(id, { ...params }) -> Stripe.TreasuryReceivedCredit
-
-
-
Retrieves the details of an existing ReceivedCredit by passing the unique ReceivedCredit ID from the ReceivedCredit list.
-
-
-
await client.treasury.receivedCredit.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.treasury.ReceivedCreditRetrieveRequest
-
requestOptions:
ReceivedCredit.RequestOptions
-
-
client.treasury.receivedDebit.create({ ...params }) -> Stripe.TreasuryReceivedDebit
-
-
-
Use this endpoint to simulate a test mode ReceivedDebit initiated by a third party. In live mode, you can’t directly create ReceivedDebits initiated by third parties.
-
-
-
await client.treasury.receivedDebit.create({ amount: 1, currency: "currency", financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.ReceivedDebitCreateRequest
-
requestOptions:
ReceivedDebit.RequestOptions
-
-
client.treasury.receivedDebit.list({ ...params }) -> Stripe.ReceivedDebitListResponse
-
-
-
Returns a list of ReceivedDebits.
-
-
-
await client.treasury.receivedDebit.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.ReceivedDebitListRequest
-
requestOptions:
ReceivedDebit.RequestOptions
-
-
client.treasury.receivedDebit.retrieve(id, { ...params }) -> Stripe.TreasuryReceivedDebit
-
-
-
Retrieves the details of an existing ReceivedDebit by passing the unique ReceivedDebit ID from the ReceivedDebit list
-
-
-
await client.treasury.receivedDebit.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.treasury.ReceivedDebitRetrieveRequest
-
requestOptions:
ReceivedDebit.RequestOptions
-
-
client.treasury.creditReversal.list({ ...params }) -> Stripe.CreditReversalListResponse
-
-
-
Returns a list of CreditReversals.
-
-
-
await client.treasury.creditReversal.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.CreditReversalListRequest
-
requestOptions:
CreditReversal.RequestOptions
-
-
client.treasury.creditReversal.create({ ...params }) -> Stripe.TreasuryCreditReversal
-
-
-
Reverses a ReceivedCredit and creates a CreditReversal object.
-
-
-
await client.treasury.creditReversal.create({ received_credit: "received_credit", });
-
-
-
request:
Stripe.treasury.CreditReversalCreateRequest
-
requestOptions:
CreditReversal.RequestOptions
-
-
client.treasury.creditReversal.retrieve(creditReversal, { ...params }) -> Stripe.TreasuryCreditReversal
-
-
-
Retrieves the details of an existing CreditReversal by passing the unique CreditReversal ID from either the CreditReversal creation request or CreditReversal list
-
-
-
await client.treasury.creditReversal.retrieve("credit_reversal");
-
-
-
creditReversal:
string
-
request:
Stripe.treasury.CreditReversalRetrieveRequest
-
requestOptions:
CreditReversal.RequestOptions
-
-
client.treasury.debitReversal.list({ ...params }) -> Stripe.DebitReversalListResponse
-
-
-
Returns a list of DebitReversals.
-
-
-
await client.treasury.debitReversal.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.DebitReversalListRequest
-
requestOptions:
DebitReversal.RequestOptions
-
-
client.treasury.debitReversal.create({ ...params }) -> Stripe.TreasuryDebitReversal
-
-
-
Reverses a ReceivedDebit and creates a DebitReversal object.
-
-
-
await client.treasury.debitReversal.create({ received_debit: "received_debit", });
-
-
-
request:
Stripe.treasury.DebitReversalCreateRequest
-
requestOptions:
DebitReversal.RequestOptions
-
-
client.treasury.debitReversal.retrieve(debitReversal, { ...params }) -> Stripe.TreasuryDebitReversal
-
-
-
Retrieves a DebitReversal object.
-
-
-
await client.treasury.debitReversal.retrieve("debit_reversal");
-
-
-
debitReversal:
string
-
request:
Stripe.treasury.DebitReversalRetrieveRequest
-
requestOptions:
DebitReversal.RequestOptions
-
-
client.treasury.financialAccount.list({ ...params }) -> Stripe.FinancialAccountListResponse
-
-
-
Returns a list of FinancialAccounts.
-
-
-
await client.treasury.financialAccount.list();
-
-
-
request:
Stripe.treasury.FinancialAccountListRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.financialAccount.create({ ...params }) -> Stripe.TreasuryFinancialAccount
-
-
-
Creates a new FinancialAccount. For now, each connected account can only have one FinancialAccount.
-
-
-
await client.treasury.financialAccount.create({ supported_currencies: ["supported_currencies"], });
-
-
-
request:
Stripe.treasury.FinancialAccountCreateRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.financialAccount.retrieve(financialAccount, { ...params }) -> Stripe.TreasuryFinancialAccount
-
-
-
Retrieves the details of a FinancialAccount.
-
-
-
await client.treasury.financialAccount.retrieve("financial_account");
-
-
-
financialAccount:
string
-
request:
Stripe.treasury.FinancialAccountRetrieveRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.financialAccount.update(financialAccount, { ...params }) -> Stripe.TreasuryFinancialAccount
-
-
-
Updates the details of a FinancialAccount.
-
-
-
await client.treasury.financialAccount.update("financial_account");
-
-
-
financialAccount:
string
-
request:
Stripe.treasury.FinancialAccountUpdateRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.financialAccount.close(financialAccount, { ...params }) -> Stripe.TreasuryFinancialAccount
-
-
-
Closes a FinancialAccount. A FinancialAccount can only be closed if it has a zero balance, has no pending InboundTransfers, and has canceled all attached Issuing cards.
-
-
-
await client.treasury.financialAccount.close("financial_account");
-
-
-
financialAccount:
string
-
request:
Stripe.treasury.FinancialAccountCloseRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.financialAccount.retrieveFeatures(financialAccount, { ...params }) -> Stripe.TreasuryFinancialAccountFeatures
-
-
-
Retrieves Features information associated with the FinancialAccount.
-
-
-
await client.treasury.financialAccount.retrieveFeatures("financial_account");
-
-
-
financialAccount:
string
-
request:
Stripe.treasury.FinancialAccountRetrieveFeaturesRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.financialAccount.updateFeatures(financialAccount, { ...params }) -> Stripe.TreasuryFinancialAccountFeatures
-
-
-
Updates the Features associated with a FinancialAccount.
-
-
-
await client.treasury.financialAccount.updateFeatures("financial_account");
-
-
-
financialAccount:
string
-
request:
Stripe.treasury.FinancialAccountUpdateFeaturesRequest
-
requestOptions:
FinancialAccount.RequestOptions
-
-
client.treasury.transactionEntry.list({ ...params }) -> Stripe.TransactionEntryListResponse
-
-
-
Retrieves a list of TransactionEntry objects.
-
-
-
await client.treasury.transactionEntry.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.TransactionEntryListRequest
-
requestOptions:
TransactionEntry.RequestOptions
-
-
client.treasury.transactionEntry.retrieve(id, { ...params }) -> Stripe.TreasuryTransactionEntry
-
-
-
Retrieves a TransactionEntry object.
-
-
-
await client.treasury.transactionEntry.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.treasury.TransactionEntryRetrieveRequest
-
requestOptions:
TransactionEntry.RequestOptions
-
-
client.treasury.transaction.list({ ...params }) -> Stripe.TransactionListResponse
-
-
-
Retrieves a list of Transaction objects.
-
-
-
await client.treasury.transaction.list({ financial_account: "financial_account", });
-
-
-
request:
Stripe.treasury.TransactionListRequest
-
requestOptions:
Transaction.RequestOptions
-
-
client.treasury.transaction.retrieve(id, { ...params }) -> Stripe.TreasuryTransaction
-
-
-
Retrieves the details of an existing Transaction.
-
-
-
await client.treasury.transaction.retrieve("id");
-
-
-
id:
string
-
request:
Stripe.treasury.TransactionRetrieveRequest
-
requestOptions:
Transaction.RequestOptions
-
-