Errors 

Stripe uses conventional HTTP response codes to indicate the success or failure of an API request. In general: Codes in the 2xx range indicate success. Codes in the 4xx range indicate an error that failed given the information provided (e.g., a required parameter was omitted, a charge failed, etc.). Codes in the 5xx range indicate an error with Stripe’s servers (these are rare).

Some 4xx errors that could be handled programmatically (e.g., a card is declined) include an error code that briefly explains the error reported.

Attributes

  • codenullable string

    For some errors that could be handled programmatically, a short string indicating the error code reported.

  • decline_codenullable string

    For card errors resulting from a card issuer decline, a short string indicating the card issuer’s reason for the decline if they provide one.

  • messagenullable string

    A human-readable message providing more details about the error. For card errors, these messages can be shown to your users.

  • paramnullable string

    If the error is parameter-specific, the parameter related to the error. For example, you can use this to display a message near the correct form field.

  • payment_intentnullable object

    The PaymentIntent object for errors returned on a request involving a PaymentIntent.

  • typeenum

    The type of error returned. One of api_error, card_error, idempotency_error, or invalid_request_error

    Possible enum values
    api_error
    card_error
    idempotency_error
    invalid_request_error

More

  • advice_codenullable string

  • chargenullable string

  • doc_urlnullable string

  • network_advice_codenullable string

  • network_decline_codenullable string

  • payment_methodnullable object

  • payment_method_typenullable string

  • request_log_urlnullable string

  • setup_intentnullable object

  • sourcenullable object

HTTP Status Code Summary
200OKEverything worked as expected.
400Bad RequestThe request was unacceptable, often due to missing a required parameter.
401UnauthorizedNo valid API key provided.
402Request FailedThe parameters were valid but the request failed.
403ForbiddenThe API key doesn’t have permissions to perform the request.
404Not FoundThe requested resource doesn’t exist.
409ConflictThe request conflicts with another request (perhaps due to using the same idempotent key).
424External Dependency FailedThe request couldn’t be completed due to a failure in a dependency external to Stripe.
429Too Many RequestsToo many requests hit the API too quickly. We recommend an exponential backoff of your requests.
500, 502, 503, 504Server ErrorsSomething went wrong on Stripe’s end. (These are rare.)
Error Types
api_errorAPI errors cover any other type of problem (e.g., a temporary problem with Stripe’s servers), and are extremely uncommon.
card_errorCard errors are the most common type of error you should expect to handle. They result when the user enters a card that can’t be charged for some reason.
idempotency_errorIdempotency errors occur when an Idempotency-Key is re-used on a request that does not match the first request’s API endpoint and parameters.
invalid_request_errorInvalid request errors arise when your request has invalid parameters.

Handling errors 

Our Client libraries raise exceptions for many reasons, such as a failed charge, invalid parameters, authentication errors, and network unavailability. We recommend writing code that gracefully handles all possible API exceptions.

// Note: Node.js API does not throw exceptions, and instead prefers the
// asynchronous style of error handling described below.
//
// An error from the Stripe API or an otherwise asynchronous error
// will be available as the first argument of any Stripe method's callback:
// E.g. stripe.customers.create({...}, function(err, result) {});
//
// Or in the form of a rejected promise.
// E.g. stripe.customers.create({...}).then(
// function(result) {},
// function(err) {}
// );
switch (err.type) {
case 'StripeCardError':
// A declined card error
err.message; // => e.g. "Your card's expiration year is invalid."
break;
case 'StripeRateLimitError':
// Too many requests made to the API too quickly
break;
case 'StripeInvalidRequestError':
// Invalid parameters were supplied to Stripe's API
break;
case 'StripeAPIError':
// An error occurred internally with Stripe's API
break;
case 'StripeConnectionError':
// Some kind of error occurred during the HTTPS communication
break;
case 'StripeAuthenticationError':
// You probably used an incorrect API key
break;
default:
// Handle any other types of unexpected errors
break;
}

Expanding Responses 

Many objects allow you to request additional information as an expanded response by using the expand request parameter. This parameter is available on all API requests, and applies to the response of that request only. You can expand responses in two ways.

In many cases, an object contains the ID of a related object in its response properties. For example, a Charge might have an associated Customer ID. You can expand these objects in line with the expand request parameter. The expandable label in this documentation indicates ID fields that you can expand into objects.

Some available fields aren’t included in the responses by default, such as the number and cvc fields for the Issuing Card object. You can request these fields as an expanded response by using the expand request parameter.

You can expand recursively by specifying nested fields after a dot (.). For example, requesting payment_intent.customer on a charge expands the payment_intent property into a full PaymentIntent object, then expands the customer property on that payment intent into a full Customer object.

You can use the expand parameter on any endpoint that returns expandable fields, including list, create, and update endpoints.

Expansions on list requests start with the data property. For example, you can expand data.customers on a request to list charges and associated customers. Performing deep expansions on numerous list requests might result in slower processing times.

Expansions have a maximum depth of four levels (for example, the deepest expansion allowed when listing charges is data.payment_intent.customer.default_source).

You can expand multiple objects at the same time by identifying multiple items in the expand array.

const Stripe = require('stripe');
const stripe = Stripe('sk_test_BQokikJ...2HlWgH4olfQ2sk_test_BQokikJOvBiI2HlWgH4olfQ2');
stripe.charges.retrieve('ch_3Ln0H22eZvKYlo2C0tgkG5bn', {
expand: ['customer', 'payment_intent.customer'],
});
Response
{
"id": "ch_3LmzzQ2eZvKYlo2C0XjzUzJV",
"object": "charge",
"customer": {
"id": "cu_14HOpH2eZvKYlo2CxXIM7Pb2",
"object": "customer",
// ...
},
"payment_intent": {
"id": "pi_3MtwBwLkdIwHu7ix28a3tqPa",
"object": "payment_intent",
"customer": {
"id": "cus_NffrFeUfNV2Hib",
"object": "customer",
// ...
},
// ...
},
// ...
}

Idempotent requests 

The API supports idempotency for safely retrying requests without accidentally performing the same operation twice. When creating or updating an object, use an idempotency key. Then, if a connection error occurs, you can safely repeat the request without risk of creating a second object or performing the update twice.

To perform an idempotent request, provide an additional IdempotencyKey element to the request options.

Stripe’s idempotency works by saving the resulting status code and body of the first request made for any given idempotency key, regardless of whether it succeeds or fails. Subsequent requests with the same key return the same result, including 500 errors.

A client generates an idempotency key, which is a unique key that the server uses to recognize subsequent retries of the same request. How you create unique keys is up to you, but we suggest using V4 UUIDs, or another random string with enough entropy to avoid collisions. Idempotency keys are up to 255 characters long.

You can remove keys from the system automatically after they’re at least 24 hours old. We generate a new request if a key is reused after the original is pruned. The idempotency layer compares incoming parameters to those of the original request and errors if they’re not the same to prevent accidental misuse.

We save results only after the execution of an endpoint begins. If incoming parameters fail validation, or the request conflicts with another request that’s executing concurrently, we don’t save the idempotent result because no API endpoint initiates the execution. You can retry these requests. Learn more about when you can retry idempotent requests.

All POST requests accept idempotency keys. Don’t send idempotency keys in GET and DELETE requests because it has no effect. These requests are idempotent by definition.

const Stripe = require('stripe');
const stripe = Stripe('sk_test_BQokikJ...2HlWgH4olfQ2sk_test_BQokikJOvBiI2HlWgH4olfQ2');
const customer = await stripe.customers.create(
{
description: 'My First Test Customer (created for API docs at https://docs.stripe.com/api)',
},
{
idempotencyKey: 'KG5LxwFBepaKHyUD',
}
);

Include-dependent response values (API v2) 

Some API v2 responses contain null values for certain properties by default, regardless of their actual values. That reduces the size of response payloads while maintaining the basic response structure. To retrieve the actual values for those properties, specify them in the include array request parameter.

To determine whether you need to use the include parameter in a given request, look at the request description. The include parameter’s enum values represent the response properties that depend on the include parameter.

Note

Whether a response property defaults to null depends on the request endpoint, not the object that the endpoint references. If multiple endpoints return data from the same object, a particular property can depend on include in one endpoint and return its actual value by default for a different endpoint.

A hash property can depend on a single include value, or on multiple include values associated with its child properties. For example, when updating an Account, to return actual values for the entire identity hash, specify identity in the include parameter. Otherwise, the identity hash is null in the response. However, to return actual values for the configuration hash, you must specify individual configurations in the request. If you specify at least one configuration, but not all of them, specified configurations return actual values and unspecified configurations return null. If you don’t specify any configurations, the configuration hash is null in the response.

If you update an Account v2 to add the customer and merchant configurations, but don’t specify any properties in the include parameter, the response might look like this:

{
"id": "acct_123",
"object": "v2.core.account",
"applied_configurations": [
"customer",
"merchant"
],
"configuration": null,
"contact_email": "furever@example.com",
"created": "2025-06-09T21:16:03.000Z",
"dashboard": "full",
"defaults": null,
"display_name": "Furever",
"identity": null,
"livemode": true,
"metadata": {},
"requirements": null
}

If you make the same request, but specify identity and configuration.customer in the include parameter, the response might look like this:

{
"id": "acct_123",
"object": "v2.core.account",
"applied_configurations": [
"customer",
"merchant"
],
"configuration": {
"customer": {
"automatic_indirect_tax": {
...
},
"billing": {
...
},
"capabilities": {
...
},
...
},
"merchant": null,
"recipient": null
},
"contact_email": "furever@example.com",
"created": "2025-06-09T21:16:03.000Z",
"dashboard": "full",
"defaults": null,
"display_name": "Furever",
"identity": {
"business_details": {
"doing_business_as": "FurEver",
"id_numbers": [
{
"type": "us_ein"
}
],
"product_description": "Saas pet grooming platform at furever.dev using Connect embedded components",
"structure": "sole_proprietorship",
"url": "http://accessible.stripe.com"
},
"country": "US"
},
"livemode": true,
"metadata": {},
"requirements": null
}