Skip to main content

Payment Intent Object

A payment intent is the server-side record of one payment's lifecycle — authorize, capture, void, refund — driven entirely from your backend. You create one with POST /v1/payment_intents; it's what every integration path ultimately charges through. This page documents the object's shape. For the how-to (auth/capture/void/refund, MIT, 3DS), see the Payment Intents guide.

{
"id": "vpi_live_8x4n2pq7m1",
"status": "succeeded",
"amount": 4999,
"currency": "USD",
"capture_method": "automatic",
"card": { "brand": "visa", "last4": "4242" },
"created_at": "2026-06-23T15:30:00.000Z"
}

Core fields​

FieldTypeAlways PresentDescription
idstringYesPayment intent ID — vpi_test_* (sandbox) or vpi_live_* (live).
statusstring: requires_action | authorized | captured | succeeded | voided | failed | cancelledYesCurrent lifecycle status — see Status lifecycle.
amountintegerYesAmount in minor units (cents), ≥ 0.
currencystringYesISO 4217 currency code (3-letter uppercase).
capture_methodstring: automatic | manualYesautomatic — capture immediately on a successful authorization. manual — authorize now, capture later via /capture.
next_actionobject | nullNoPresent when a server-redirect 3DS challenge is required: { "type": "redirect_to_url", "redirect_to_url": { "url": "…" } }. Redirect the buyer to url, unless you created the payment with next_action_presentation: "in_page" (the check in a pop-up); the intent settles after the challenge.
client_confirmobject | nullNoBrowser-confirmation handle: { binder, client_secret }. Do not build on it: handle a 3-D Secure challenge with next_action, which is the path for a charge sent with payment_method. ⛔ client_secret is a credential whenever present: it authorizes the 3-D Secure step-up for this intent. Forward it only to the buyer's browser and redact it everywhere else: a payment result written whole to a log, an APM breadcrumb or an error tracker takes this field with it.
decline_codestring | null: card_declined | insufficient_funds | expired_card | incorrect_cvc | incorrect_zip | incorrect_number | card_velocity_exceeded | fraudulent | stolen_card | lost_card | do_not_honor | issuer_unavailable | processing_error | blocked_by_rule | authentication_not_completed | authentication_failed | recurring_mandate_required | generic_declineNoNormalized decline reason on a failed intent (see Decline codes).
rule_codestring (≤ 64) | nullNoWhich of your own provider rules refused the charge. Present only when decline_code is blocked_by_rule; null on every other outcome. Carries the custom code you set on that rule, with the provider's own prefix stripped — max 64 chars, and null if you left the rule unnamed. See Telling your rules apart.
actionstring | null: soft | hard | fix_and_retry | genericNoWhat to do about a decline — soft, hard, fix_and_retry or generic, derived from decline_code through one published mapping (see action).
network_advicestring | null: do_not_try_again | try_again_later | confirm_card_data | stop_recurringYesThe card network's own advice about presenting this card again, when it gave one. null unless the payment was declined. stop_recurring: the cardholder cancelled recurring payments to you, so stop the arrangement and do not charge this card for it again. do_not_try_again: ask for a different payment method. try_again_later: wait, see network_advice_retry_after_ms. confirm_card_data: ask the cardholder to confirm or re-enter the card. null is not permission to retry. Read it with action, and when they differ, follow the stricter one.
network_advice_retry_after_msinteger | nullYesWith network_advice: "try_again_later", the shortest wait the card network named before this card may be presented again, in milliseconds, counted from the decline. It is the earliest time, not a schedule. null when the network named no wait (which is not "retry now") and for every other network_advice value.
decline_messagestring | nullNoBuyer-safe wording for the decline — the field to show a shopper. Not the same string as failure_reason, which is written for you and names the fraud, lost and stolen signals. See Showing a decline to the buyer.
payment_method_idstring | nullNoThe saved card this payment vaulted (vp_pmt_*), reusable for later merchant-initiated charges. null when the payment vaulted nothing: a guest payment with no buyer attached, a payment nobody agreed to save the card on, or one that never succeeded. Returned by GET /v1/payment_intents/{id} only — it is not on the create response, because the card is vaulted when the charge completes. That makes this the surface to use when the token never reached your server at charge time: a payment sent through 3-D Secure finishes after your charge call has already returned, so the charge response carries no token for it. Unlike next_action, it is not tied to status — a saved card outlives the payment that saved it, so later reads keep returning it. Same value as token on the charge-at-submit response and id on a POST /v1/tokens response.
cardobject | nullNoThe card on the create response: { "brand": …, "last4": … }. brand is one of visa, mastercard, amex, discover, diners, jcb, unionpay, unknown; last4 is 4 digits. The full card number is never returned. A retrieve, capture or void returns card from our own records with the first six digits as well: see Fields on a read. On a charge of a saved Apple Pay or Google Pay payment method, this is the card shown when it was saved, the one the buyer recognises, not the wallet's device number.
processor_connectionobject | nullYesWhich of your payment connections processed this payment, as { id, name }. Tells apart two connections to the same processor. null when no connection was reached: the payment was refused before it was routed, or it predates connections being recorded on payments. The charge.* and payment_intent.* webhooks carry the same value. Server responses only: publishable-key responses never carry it.
avs_result_codestring | null: match | partial_postal | partial_address | no_match | unavailable | not_supportedNoNormalized Address Verification (AVS) result. null when no billing address was sent or no result was returned. Gateway-independent — raw processor codes are not exposed. On a charge that goes through 3-D Secure it is null on the create response and filled in when the payment completes successfully: read it from GET /v1/payment_intents/{id} or the charge.succeeded / payment_intent.succeeded webhook. It stays null when the charge is declined after the buyer authenticates.
cvv_result_codestring | null: match | no_match | not_provided | unavailableNoNormalized card security-code result. On a charge that goes through 3-D Secure it is null on the create response and filled in when the payment completes successfully: read it from GET /v1/payment_intents/{id} or the charge.succeeded / payment_intent.succeeded webhook. It stays null when the charge is declined after the buyer authenticates.
network_transaction_idstring (≤ 128) | nullYesThe card network's own identifier for this charge (Visa's Transaction Identifier, Mastercard's trace id), which the networks use to link a later merchant-initiated charge, such as a renewal, to this one. Opaque: store it exactly as received and never parse it. null means not reported yet, not "none": some connections report it only once the payment settles, and a charge waiting on 3-D Secure has not reached the network yet, so read the payment intent again later. Card charges only. Not returned to the browser.
mit_original_transaction_idstring | nullYesThe earlier payment this merchant-initiated charge is linked to for the card networks: the mit.original_transaction_id you sent, or, when you left it out on a saved-card charge, the card's first approved customer-present payment. null on a charge with no mit block, and on a charge linked to the card's $0 card check instead (mit_anchor_source: "card_check", where available on your account). On a customer-initiated charge on a saved card: the id you sent when it passed the anchor checks, otherwise null.
mit_anchor_sourcestring | null: payment | card_checkYesWhat this merchant-initiated charge is linked to. payment: the earlier payment named in mit_original_transaction_id. card_check: the approved $0 card check made when the card was saved, used when the card has no earlier customer-present payment and the check was made for the same use as this charge (its card_check.stored_credential_use equals mit.reason; where available on your account); mit_original_transaction_id is then null. null on a charge without an mit block, and on a customer-initiated charge on a saved card made with no anchor. Not on the payment webhooks: read it here.
created_atstring | nullNoISO 8601 creation timestamp.
metadataobjectNoMerchant-provided key-value pairs you set at creation.
buyer_emailstring (≤ 254)NoOn the create response, echoes back the buyer_email you sent, confirming it was accepted for buyer attribution. On a retrieve, capture or void it is the effective buyer's stored email, so it can be present even when that call sent no email (the same effective-buyer rule as buyer_id below). Omitted entirely when there is none to report: it is never null, so test for the key's presence rather than comparing to null.
buyer_idstring (≤ 200)NoOmitted when no effective buyer exists — never null. Echoes the effective buyer this charge was attributed to — which is not always the one you sent. If the stored payment_method you charged carries its own buyer, that one wins; otherwise it is the buyer_id on your request. Present only when an effective buyer exists. ⚠️ On an idempotency-key replay this echoes what this request asked for, not what is stored — the buyer write is skipped entirely on a replay, so a re-sent create that adds or changes a buyer returns the new value while the stored attribution keeps the original. On a first (non-replay) request it is a genuine confirmation that the best-effort linkage landed; on a replay it is not.
buyerobjectNoEchoes the nested buyer object you sent at creation, confirming it was accepted. buyer.metadata is echoed after privacy scrubbing, so it reflects what was stored rather than what you sent. Omitted when you did not send one — never null. See Buyers.
buyer_ip_address_forwardedbooleanNoWhether the buyer_ip_address you sent was actually passed to the processor. Present only on the create response, and only when you sent one: the shared projection behind retrieve, capture and void does not carry it, so read it from the charge response rather than a later fetch. true means it was forwarded. false means we accepted it and did not send it, either because the charge was merchant-initiated (no shopper is present, so no address is asserted) or because the payment connection your account routes through is not one that carries it. Treat false as "this charge got no IP-based screening" rather than an error. The IP address itself is never echoed back. See Buyer IP address.
fraud_evidence_forwardedbooleanNoWhether the fraud_evidence you sent was passed to your payment processor, to be kept on its record of the charge. Present only on the create response, and only when you sent fraud_evidence: it is not repeated on an idempotent replay of the create call, or on retrieve, capture and void, so read it from the first response. true means the fields were sent with this charge. false means they were accepted but not sent, because the payment connection your account routes through does not carry them; the charge itself went ahead as normal. The values themselves are never echoed. See Fraud evidence.
resolved_descriptorobject | nullNoWhat actually went to the payment provider as the statement descriptor for this charge — present on the create response. One of { "kind": "skipped", "reason": … } when none was applied, { "kind": "suffix", "suffix" } for a dynamic tail on your registered prefix, or { "kind": "descriptor", "descriptor": {…} } for a full block. kind never names a payment provider. ⚠️ The brand-name prefix is best-effort and is usually fixed by your processor's merchant-account registration, not by this value; whether the dynamic tail reaches the statement depends on the processor connection the charge was routed to. This field records what was sent, not what the bank printed. See Statement descriptors.
pulseStreamTokenstring | nullNoShort-lived signed token for the real-time status stream of this payment intent. Forward it to the buyer's browser; the browser SDK sends it as Authorization: Bearer to resolve handleAction() as soon as the payment finishes, instead of waiting for its timeout. null when live status updates are not available for this intent; fall back to your timeout path. Opaque to your code: don't log it, and never put it in a URL. ⚠️ The name is camelCase deliberately, like pulseToken. ⚠️ The stream this token is for is not generally available today, so in practice this arrives null and the fallback path is the live path: see Streaming endpoints.
pulseTokenstring | nullNoDeprecated: use pulseStreamToken. Always null in production, so a client that still reads it takes its timeout path.
three_d_secureobject | nullNoWhat cardholder authentication (3-D Secure) actually did on this payment, as opposed to what was requested or configured: outcome is one of authenticated, attempted, not_authenticated, cancelled (the shopper abandoned the challenge), failed, not_performed or unknown, alongside method, version and eci. Read eci for liability; never treat attempted as authenticated. After a bank challenge, and for any payment in the embedded payment form (where the check runs inside the form), the result is recorded after the payment's outcome, approved or declined, from the record kept by whoever ran the check: read it by retrieving the payment once it has concluded, not from the first response. A declined payment carries the result too, so you can see whether the shopper was authenticated before the bank said no. It is recorded a moment after the decline, so the failure webhook does not carry it: retrieve the payment after that webhook. It stays null when the shopper abandons the challenge (no charge, so no result), when a check that did not pass left no processor charge to read the result from, and on a connection that reports no authentication record. null and outcome: "not_performed" are different answers: null means no concluded result was recorded, never "not authenticated"; not_performed means the payment was inspected and no authentication took place.
client_read_secretstring | nullNoRead-only browser secret (vp_pirs_*) for an in-page bank check. Only on a payment created with next_action_presentation: "in_page", while it is requires_action with a next_action; null otherwise, and on an Idempotency-Key replay. Pass it to the page that calls vora.handleNextAction(); it is shown once: keep it out of URLs and logs, and do not store it beyond that page.
recurringobjectNoOn a subscription sign-up only (the create response and its replay; not on a declined charge): the terms resolved from the product. product, product_ref, interval, interval_count, amount (the renewal price), first_amount (what this payment charged), currency, and disclosure, our default sentence for the terms.
subscriptionobject | nullNoOn the create response of a subscription sign-up only, not on a retrieve: the subscription this payment created, { id, status, next_bill_at }, once it exists. null until then: when building it takes longer, when the charge needs the shopper's 3-D Secure check, or on a manual-capture charge until it is captured. subscription.created then carries this payment's payment_intent_id.
warningsarray of objectNoNon-fatal notes, a list of { code, message, field }, absent when there is nothing to report. On a subscription sign-up: something about the shopper's agreement or routing; the subscription starts either way (Warnings about the agreement). On a test payment with mirror: test_store_order_not_written when test orders are off for that store. On a customer-initiated charge on a saved card: mit_anchor_not_used when the mit.original_transaction_id you sent was not used.

Fields on a read​

GET /v1/payment_intents/{id}, POST /v1/payment_intents/{id}/capture and POST /v1/payment_intents/{id}/void return one shape. It also has these fields, which the create response does not. Each item of GET /v1/payment_intents has them too, except late_money_outcome.

FieldTypeAlways PresentDescription
cardobjectYesThe card, from our own records, as { brand, last4, bin }. Always an object: each field is null when it is not known. bin is the first six digits of the card number, which name the card's issuing bank and card type. The full card number is never returned.
processor_responseobject | nullYesThe card processor's own answer on a failed payment, as { code, description }. null when the processor's answer was not recorded, and on a payment that is not failed. Use it to match the processor's own reports. To decide what to do, read decline_code and action: they mean the same thing whichever processor answered. code is the processor's code (up to 64 characters). description is the processor's text, shortened to 200 characters. In it, a number of 6 or more digits is replaced with [REDACTED_NUMBER], and a field value the processor repeats back is replaced with [REDACTED_VALUE]. description is null when the processor sent none, or when we could not return it safely. Treat both as untrusted input: escape them wherever you display them, never branch on them, and never show them to the buyer. For the buyer, use decline_message.
attemptsarray ≤ 50 | nullYesEvery time this payment was sent to one of your payment connections, in order. When a connection refuses a payment, your routing can send it on to the next one, and each of those tries is one item: see One try. The last item is the connection that decided the payment, the same as processor_connection. An empty list means no connection was tried, for example because one of your own rules refused the payment first. null when we do not hold the record: read attempts_status. It is recorded a few minutes after the payment reaches its final status, from our own records. Payments made before 2 November 2026 are not recorded.
attempts_statusstring: complete | pending | unavailableYesWhether attempts is the full record. complete: it is (the list can be empty). pending: the payment is recent and its record is not ready yet, so attempts is null; read the payment again in a few minutes. unavailable: we do not hold the record, so attempts is null. The payment was made before the record existed, did not go through your connections, or the record could not be read.
late_money_outcomestring | null: reversing | reversed | reverse_failed | manual_refund_pending | manually_refunded | kept_by_merchantYesWhat happened to money that arrived after this payment read failed, cancelled or voided. Always present: null means no such money arrived. The payment's status does not change. Given back automatically: reversing (we are giving it back now), reversed (it was given back: refunded, or the hold released), reverse_failed (giving it back has not completed; our team finishes it if needed, so do not refund it yourself). Given back by hand, when the automatic return does not cover the payment: manual_refund_pending (the buyer was charged and the money is not given back yet; our team contacts you about it), manually_refunded (our team recorded it as given back), kept_by_merchant (you kept the money, for example because you fulfilled the order, and our team recorded that decision). While it reads manual_refund_pending, you can refund it yourself by its settlement row. A refund by payment_intent is refused, because the payment does not read succeeded. It reads manual_refund_pending until our team records the outcome, including a refund you made. A recorded manually_refunded or kept_by_merchant does not change. When late money arrives more than once on one payment, the field shows the outcome that still needs something first. Late money given back by hand before 16 November 2026 reads null. It also reads null when our records cannot be read at that moment: read the payment again. Not on GET /v1/payment_intents list items.

One try: attempts items​

FieldTypeDescription
attemptinteger1 for the first connection tried, then 2, 3 and so on, in order.
processor_connectionobject | nullThe connection this try was sent to, as { id, name }: the same values as the payment's processor_connection. null when the try did not name one.
resultstring: approved | declined | errorapproved: the connection approved it. declined: the connection or the card's bank refused it. error: the connection could not process it. A try that sent the buyer to the bank's security check (3-D Secure) takes its result from the payment it ended. If the buyer did not finish the check, it is declined with decline_code authentication_not_completed. If the buyer finished it, it is declined with the payment's decline_code when the bank then refused the payment, and approved when the bank accepted it. Such a try has no processor_response. Some earlier records leave such a try out of attempts.
decline_codestring | nullWhy this try was refused, from the same list as the payment's decline_code. null on an approved try, and when no reason was given. Treat a value you do not know as a hard decline.
processor_responseobject | nullThe processor's own answer to this try, as { code, description }, with the same rules as the payment's processor_response. null on an approved try.
outcomestring: approved | bank_declined | merchant_rule_blocked | refused_before_bank | request_rejected | authentication_failed | authentication_not_completed | abandoned | provider_unavailable | system_error | unclassified | authorized | in_progress | voidedThe outcome of this try.
network_advicestring | null: do_not_try_again | try_again_later | confirm_card_data | stop_recurring | nullThe card network's advice about presenting this card again, by the same rule as the payment's network_advice. On the last try of a failed payment it is the payment's own value. On an earlier try it comes from that try's response code only, so it is often null there. null is never permission to retry.
network_advice_retry_after_msinteger | nullWith network_advice: "try_again_later" only: the shortest wait the network named, in milliseconds. Otherwise null.
created_atstringWhen the connection answered.

To count approvals and declines per connection, count the items of attempts by processor_connection.id. Count only payments whose attempts_status is complete. See Payment reports.

Status lifecycle​

cancelled is spelled with two ls on a payment intent. A refund's status is spelled canceled, with one. Compare each against its own spelling.

StatusMeaning
requires_actionA 3D Secure (or other) challenge must complete before the intent can settle. Send the buyer to next_action.redirect_to_url.url, or show it in a pop-up for an in_page payment. With no next_action the payment is still processing: wait for the webhook, which can take up to a day.
authorizedFunds are held but not captured. Only reachable with capture_method: "manual" — capture with /capture or release with /void.
capturedA previously authorized intent was captured. Not terminal — it transitions on to succeeded when settlement confirms (or failed if the provider rejects it). ⚠️ A refund requires succeeded: POST /v1/refunds rejects a captured intent. Wait for succeeded before refunding.
succeededMoney has moved, and this is terminal. Reached from captured when settlement confirms, from authorized when a manual capture settles in the same call, or directly on capture_method: "automatic".
voidedAn authorized intent was cancelled before capture. No money moves.
failedThe authorization or capture failed. See decline_code for the reason. A failed payment intent with every decline field null and no webhook can be the record of a charge the provider refused before any money moved.
cancelledThe payment was waiting on the bank's security check (3-D Secure) and was cancelled before it completed. Final; no money was taken.
┌─► succeeded settlement confirmed
┌─► captured ───┤
│ └─► failed provider rejected the capture
│
┌─► authorized ─┼─► succeeded capture settled in the same call
│ ├─► voided released before capture
│ └─► failed
│ capture_method: "manual"
│
requires_action
│
├─► succeeded capture_method: "automatic"
├─► failed declined (decline_code set)
└─► cancelled bank check cancelled, nothing taken

terminal: succeeded · voided · failed · cancelled
refunds: POST /v1/refunds accepts succeeded only

authorized can reach succeeded without passing through captured: on card networks the capture and the settlement happen in the same call, so the intent moves straight to its terminal status. Do not wait to observe captured — read the status you are given, and treat succeeded as the signal that money moved.

The client-side result of a charge is a UX signal only. Always confirm settlement server-side via the payment_intent.succeeded / charge.succeeded webhook before fulfilling.

Decline codes​

When status is failed, decline_code carries the normalized reason (branch on this rather than a raw issuer code), and action tells you what to do about it. Both are null on any non-failed intent.

A decline is a 201, not an error

A declined payment intent returns 201 Created with status: "failed", or 200 on an idempotent replay. The request succeeded; the payment did not. There is no 4xx for a decline.

So parse the response body on success statuses. A client that only reads the body when the status is an error will never see decline_code, action, rule_code or decline_message — and the failure is silent: no exception is raised, the decline branch simply never runs, and every decline looks like a blank result.

action — retry or don't​

action is derived from decline_code through one published mapping, so you can build retry and dunning logic without maintaining your own code table.

actionMeaningWhat to do
softTransient.A later attempt on the same card may succeed. It is not a signal to retry now: space attempts out over days, not seconds or minutes.
hardTerminal.Do not retry. The buyer needs a different payment method.
fix_and_retryThe buyer mistyped something.Retry only after they correct it — don't retry unchanged.
genericNo reason supplied.Treat as hard unless you have a reason not to.
decline_codeaction
insufficient_funds, issuer_unavailable, processing_error, card_velocity_exceeded, do_not_honor, authentication_not_completed, authentication_failedsoft
stolen_card, lost_card, fraudulent, blocked_by_rule, recurring_mandate_requiredhard
expired_card, incorrect_cvc, incorrect_zip, incorrect_numberfix_and_retry
card_declined, generic_declinegeneric

Card network retry limits. Each new POST /v1/payment_intents on a declined card is a new attempt as far as the card networks are concerned. They limit repeat attempts on the same card and charge fees for excess ones, billed to you through your acquiring bank. Von Payments does not enforce a wait or a cap on retries from your server, so build the limits into your retry logic. Visa: after a decline Visa classes as "issuer will never approve", do not try that card again; for declines it classes as temporary, Visa caps how many times you may retry the same card within 30 days. Mastercard: when its advice is "do not try again", do not retry that card; repeated declined attempts are charged. Network rules change, so confirm the current limits with your acquiring bank. Treat hard as final and keep soft retries few and spread out.

authentication_not_completed means the buyer was sent to their bank's 3-D Secure check and did not finish it: nobody declined the payment and nothing was charged, so offer another try with the same card. Payments before 2026-10-12 reported it as generic_decline or with no reason; those that read generic_decline were updated to it by a one-off correction in October 2026, and webhooks already delivered for them were not re-sent. authentication_failed (since 2026-10-22) means the buyer went through the check and it did not pass, including when they cancelled it: usually no charge was sent, and the buyer can try again or use a different payment method (on a checkout session, in a new session: a failed check ends it). Earlier payments reported it as generic_decline (or do_not_honor where the payment processor ran the check) and were updated to authentication_failed on 2026-10-23; webhooks already delivered for them were not re-sent. Since 2026-11-14, when only the payment processor's own notice says the check did not pass, the payment is corrected from that notice a few minutes after it ends: to authentication_failed, or to authentication_not_completed when the notice came 9 minutes or more after the check opened (the check timed out). Earlier payments of this kind were corrected the same way; webhooks already delivered for them were not re-sent. If the bank approved the payment even though the check did not pass, Von Payments does not keep that approval: the payment is reported failed with this code, and any amount held is released or any amount taken is refunded automatically. A charge.refunded event with reason: abandoned_payment_reversed then follows the charge.failed. Handling.

incorrect_number (since 2 November 2026) means the card number is wrong. Ask the buyer to check the number and try again. Browser-facing responses report it as incorrect_card_details, so a page anyone can script does not tell a card tester which detail was wrong.

recurring_mandate_required (since 3 November 2026) means an automatic charge (merchant-initiated, with the customer not present) on a card issued in India was refused, because the customer's first payment set up no recurring-payment mandate. It was refused before any bank, and nothing was charged. Do not retry the same automatic charge: charge the card while the customer is present, or use a different card. The create call answers 422 recurring_mandate_required. The failed payment intent recorded for that answer carries this decline_code. No webhook is sent for that payment. Payments refused this way before 3 November 2026 reported no reason.

Since 2 November 2026, when the payment provider's own reason is not specific but the processor's answer is (for example "do not honor"), the processor's answer decides. So fewer declines read generic_decline.

blocked_by_rule is a routing rule you configured refusing the charge before any issuer saw it: its action is hard, and the rule that fired is reported as rule_code (null if you gave the rule no code). The full value reaches secret-key surfaces (this object and the charge.failed webhook, where it is named failure_code); browser-facing responses report it as card_declined with no rule_code, except a rule that refuses a card brand outright, which reaches the browser as card_brand_not_accepted. GET /v1/payment_intents/{id} returns the same decline_code, action, decline_message and rule_code on a failed payment, whichever way it was taken (your server, the embedded card form or a checkout session); all four are null on any other status. On a provider that does not distinguish a rule refusal it arrives as generic_decline. Handling.

3D Secure: next_action​

When a requires_action intent carries next_action, send the buyer to next_action.redirect_to_url.url, having set return_url on the create call. A payment created with next_action_presentation: "in_page" shows the check in a pop-up on your page instead. That is the same whether you use Embedded Fields or call the API directly. If that redirect never reached the buyer, read the intent again: GET /v1/payment_intents/{id} returns the same next_action, with issued_at for its age, for as long as the intent is requires_action.

A requires_action intent with no next_action is still processing: there is nothing for the buyer to do, so do not retry the charge, and wait for the webhook. That can take up to a day, because when the processor sends no webhook a daily reconciliation records the outcome, so do not put a shorter timeout on this state. See Embedded Fields → 3D Secure.