Skip to main content

Vora.js changelog

What changed in each release of the Von Payments browser SDK (vora.js).

  • https://js.vonpay.com/v1/vora.js updates automatically. New releases roll out in stages, so this page is where to see what changed.
  • A pinned URL (https://js.vonpay.com/v1.37.0/vora.js) never changes. Pin a version if you need to control when you move.
  • This file is served at https://js.vonpay.com/v1/CHANGELOG.md and on docs.vonpay.com.

The format follows Keep a Changelog. Releases before 1.30.0 are not listed here.

1.54.1 — 2026-11-18​

1.54.1 replaces 1.54.0, which was never rolled out to shoppers. It includes everything listed under 1.54.0 below. Rolls out in stages, like every release. Nothing changes for your integration.

Fixed​

  • A browser's saved card fills the name on card again. When a shopper picks a saved card in Chrome, the name-on-card field is now filled together with the card number, expiry and security code. In 1.51.0 to 1.53.0 the name stayed empty, and submit() stopped with "Cardholder name is required" until the shopper typed it. The field asks the browser for the card's name again (autocomplete="cc-name"). The card number, expiry and security code stay in the secure card fields, never in your page.

1.54.0 — 2026-11-18​

Rolls out in stages, like every release. Nothing changes for your integration.

Changed​

  • The embedded payment form never lists PayPal, Klarna or Affirm. These methods approve on their own pages, so they stay off the embedded form. Before this release it hid PayPal only. Von Payments can hide more methods for a checkout, never fewer. Card fields are unchanged.

1.53.0 — 2026-11-15​

Rolls out in stages, like every release. Nothing changes for your integration unless you call the new vora.handleNextAction(), your checkout starts a subscription, or a payment is refused because the checkout was set up for another way to pay (see the first item).

Added​

  • Clear errors when Von Payments refuses a payment before anything is charged. Each refusal below now has its own FrameError code, with a message you can show the shopper that ends "Nothing was charged." Before, they arrived as frame_tokenization_failed or frame_session_not_ready, both of which read as a failure to retry. retryable is false on all of them except frame_recurring_signup_in_progress.

    On the card charge of a checkout created with recurring (its payment starts a subscription):

    • frame_recurring_session_unavailable — starting a subscription from a checkout is not available on your account right now. Retrying does not help: sell without recurring, start the subscription from your server, or contact Von Payments support.
    • frame_subscription_consent_required — the charge did not carry the shopper's agreement to be charged for each renewal. Show the checkout's recurring.disclosure next to the pay button and send the agreement with collection.submit({ setupForFutureUse: "off_session" }) or a save-for-future-use box the shopper ticks; the shopper can then pay again on the same checkout.
    • frame_invalid_recurring — this checkout cannot start a subscription. Create a new checkout; if that is refused the same way, contact Von Payments support.
    • frame_recurring_terms_changed — the subscription's price or schedule changed after the shopper was shown it. Show the current terms before the shopper pays again: create a new checkout when the product changed, or show the checkout's new recurring.disclosure when your server changed it.
    • frame_recurring_already_subscribed — the shopper already has a live subscription to this product. Point them to their subscription link; to restart it on a new card, create the checkout with the same buyerId it was created under.
    • frame_recurring_signup_in_progress — another sign-up for the same shopper and product has not finished. retryable: true: let the shopper pay again in a moment with the same card. If the other payment went through, the next try is refused with frame_recurring_already_subscribed, and nothing is charged twice.
    • frame_recurring_not_enabled — Subscriptions is not switched on for your account. Sell without recurring and contact Von Payments support; starting the subscription from your server is refused too until then.

    On a card save or wallet payment, and on the card charge:

    • frame_capability_not_supported — the checkout was set up for another way to pay: a checkout that starts a subscription (pay it with the card form and collection.submit()), one that saves cards on the hosted payment page only (send the shopper to its checkoutUrl), or one sent through your own payment gateway with a manual capture (create it without captureMethod: "manual"). No card is saved.

    In HIGH_SEVERITY_FRAME_ERROR_CODES (no shopper action fixes them): frame_recurring_session_unavailable, frame_subscription_consent_required, frame_invalid_recurring, frame_recurring_not_enabled and frame_capability_not_supported.

  • vora.handleNextAction(): the bank's security check (3-D Secure) for a payment your server created, in a pop-up on your page. For a charge on a saved card or a one-click add-on: create the payment intent with next_action_presentation: "in_page" and a return_url on your page's origin, pass its id and client_read_secret to vora.handleNextAction() (as paymentIntent and clientReadSecret), and the call resolves with the payment's outcome as Von Payments records it. Show that result, and fulfil the order only from your server's own read of the payment or the webhook. A decline throws frame_payment_declined with declineCode, as the card form does. When the call ends without an outcome it throws the new frame_next_action_outcome_unknown with a reason (next_action_unusable, next_action_unavailable, code_not_loaded, no_page): the payment may already be paid, so read it from your server before taking any new payment. TypeScript: FrameError.reason is now ThreeDsRequiredReason | NextActionOutcomeUnknownReason; check code first to narrow it. If the shopper closes the pop-up, or the check runs out of time, it resolves requires_action with a reason: that is not "unpaid". Your server reads the payment and may cancel it; take payment another way only when the cancel succeeds and the payment reads cancelled or failed (every other answer: it is paid, or wait for its webhook). Your page's CSP needs the new next-action rows of vora.cspSources().

Changed​

  • A bank security check (3-D Secure) that did not pass or was not completed now reads "The bank's security check (3-D Secure) did not pass." / "… was not completed." followed by "No charge was confirmed." (it used to say "Nothing was charged."). Branch on declineCode, not on the message.
  • The Apple Pay and Google Pay buttons now tell Von Payments when a shopper taps one and how the payment sheet ended: approved, cancelled or failed. A tap that never ends shows us a sheet that stopped responding, so we can find it without waiting for a report. Each report is a short fixed code with the SDK version, the browser family and the checkout session id. It never includes card or wallet data, the amount or the shopper's details. It is sent on live keys too; set telemetry: false to turn it off. Nothing changes for your integration or the shopper.

1.52.0 — 2026-11-09​

Rolls out in stages, like every release. Nothing changes for your integration unless you pass the new option, or your account does not accept a card brand (see the first item).

Added​

  • When your account does not accept a card brand (for example American Express), the card form now says so as soon as the shopper types a card of that brand, before anything is sent. The card element's change event carries error.code frame_card_brand_not_accepted with complete: false, and collection.submit() returns the same code without saving or charging anything. The refusal does not use up any of the checkout's payment attempts. Typing a card of another brand clears the error. Show error.message and let the shopper enter another card on the same checkout; retryable: false means that same card will never be accepted. If a card of that brand still reaches Von Payments (for example a saved card), the card save or charge is refused with the same code and nothing is charged. Accounts that accept every brand see no change.
  • collection.submit({ billingDetails: { firstName, lastName } }) sends the shopper's given and family names from your own form with the card charge, when the card form charges at submit. Each name is trimmed; a blank name is not sent. A name that is not text, is longer than 50 characters (an emoji counts as 2 or more), or holds a control character is refused before anything is sent (frame_field_validation_failed), so nothing is charged. When you send either name, Von Payments' checkout takes both from this payment; send neither and it uses the names stored on the checkout session. Not sent with a saved card, Apple Pay, Google Pay or the embedded form. After a declined card, pass the names again on the next submit(). The names are checked on every submit(), even one that does not send them, and invisible formatting characters (zero-width space, line separators, text-direction overrides) are refused.
  • A repeat submit() after a lost or pending answer: with the same details it is the same try (the checkout answers with the first result); with changed details (names, address, save choice, or a total changed by fetchUpdates()) it is a new try with what the shopper chose now. Still one payment per checkout: if an earlier try went through, submit() reports it as paid.

Fixed​

  • An already-paid checkout answering a repeat submit() (for example after a lost answer) was reported as a failure (frame_tokenization_failed); it is now reported as paid.

1.51.1 — 2026-11-13​

Rolls out in stages, like every release; pin v1.50.0 if you need time to check your page first. Includes everything listed under 1.51.0 below: 1.51.0 itself was never rolled out to pages on /v1/vora.js.

Fixed​

  • Google Pay now completes in Safari, Firefox and other browsers outside Chrome. Before, a tap on the Google Pay button there opened Google's window, which then never moved past its loading screen, and the express-checkout element reported nothing. Taps a page script makes with click() are still ignored, as before.

1.51.0 — 2026-11-09​

Rolls out in stages, like every release; pin v1.50.0 if you need time to check your page first.

Security​

  • Every file vora.js loads after the main script is now checked against the hash its release recorded for it, before it runs. A file whose bytes differ is not run: the call that needed it fails with frame_binder_load_failed, as if the file could not load. So a version pinned with integrity now covers every file of that version, not only the main script. Chrome, Edge (66+) and Firefox (115+) check through <link rel="modulepreload" integrity>; Safari and every iPhone and iPad browser check through a module <script integrity>, because Safari does not yet enforce the hash on a preload. Older Chrome and Firefox load the files as before, without the check. No change to your Content-Security-Policy. On a page that enforces Trusted Types in Safari, the files are refused rather than loaded unchecked.
  • The name-on-card field now asks the browser for a person's name (autocomplete="name"), not a card name, so the browser's saved-card autofill is never offered to other inputs on your page.
  • The card form's address must now be exactly one of Von Payments' two card-form addresses; any other address in a session answer is ignored and the default form is used.
  • The optional bot check ignores messages that did not come from its own frame through the browser.
  • A session's client secret is now also held for https://checkout.vonpay.com:443 (the default port written out), matching the server SDKs' list exactly.

Added​

  • New error code frame_session_update_conflict (retryable: true, status 409): your server changed the checkout (for example named the guest with buyerEmail) just as the shopper pressed Pay. Nothing was charged and the form stays open: let the shopper press Pay again with the same card. Before 1.51.0 this arrived as frame_tokenization_failed with status 409.
  • Every call to the Von Payments checkout API carries an X-Vora-Version header naming the vora.js version, so Von Payments can compare a new release against the previous one for your store while it rolls out. It is sent only to checkout.vonpay.com / checkout-staging.vonpay.com, never to an apiBaseUrl of your own.

Changed​

  • The embedded payment form no longer lists PayPal.
  • When a card cannot be saved because the shopper's connection failed, the error now says so (failure_hint: "network_error", "Nothing was charged; try again") instead of asking the shopper to check their card details.
  • The live payment-status stream no longer puts its token in the URL. PulseClient and subscribeToPaymentIntent() now open the stream with fetch() and send the token in an Authorization: Bearer header, so the token no longer appears in request URLs or server access logs. They fall back exactly as before when the stream is not available.
  • The stream now keeps going past one token's life (about 5 minutes). While the stream is open, vora.js swaps the token for a fresh one shortly before it expires, and it reconnects on its own after a dropped connection: a few tries, waiting longer each time, resuming from the last update received. Live updates for one payment can last up to 30 minutes from when its first token was issued. After that, or once the checkout refuses a fresh token, the stream falls back as when it is unavailable. Nothing to change in your code: keep passing the create response's token.
    • Pass the payment intent's pulseStreamToken from the create response as pulseToken. The response's older pulseToken field is always null in live mode.
    • The stream token is sent only to the Von Payments checkout (https://checkout.vonpay.com or https://checkout-staging.vonpay.com). For any other baseUrl, nothing is sent and the stream falls back as when it is unavailable, with a console warning.
    • If your page reaches the checkout through your own proxy (a relative path such as /vp-proxy included), pass allowCustomBaseUrl: true to new PulseClient() or subscribeToPaymentIntent(); the token then goes to your proxy. Forward POST /v1/public/payment_intents/{id}/stream_token as well as the stream itself.
    • baseUrl must still resolve to an https: address (plain http: only for localhost, 127.0.0.1 and [::1]); a relative path is judged by your page's own address. Anything else throws a TypeError from new PulseClient(), and subscribeToPaymentIntent() falls back without connecting.
    • A stream ends on its own 35 minutes after it started (the checkout stops renewing the token after 30), and then falls back as when it is unavailable.
    • The stream code loads on demand, the first time your page starts a stream, instead of being part of vora.js. If that file cannot be loaded within 10 seconds, the stream falls back the same way as when the stream is unavailable.
    • Your Content-Security-Policy needs nothing new: the stream code comes from the same js.vonpay.com address as vora.js, and the stream and its token renewal use connect-src for the API host, as before.
  • The Google Pay sheet's button now reads "Pay now" instead of "Continue". Approving the sheet completes the payment, so the button says so. A sheet with a zero total keeps Google's own label. Nothing else about the express checkout flow changes.

1.50.0 — 2026-11-05​

Served to every page that loads the auto-updating v1 URL since 2026-11-13. Nothing changes for an embedded form that does not name a customer.

Changed​

  • On the embedded card form, a customer's saved cards are listed only when Von Payments' checkout allows it for that checkout. It does so when your server declared a save and set savedPaymentMethodOptions.paymentMethodRedisplay: "enabled" with a secret key, and the shopper agreed to show every one of their saved cards. Otherwise the form shows a new-card form without the saved cards, whatever display your page passes.
  • display: "addOnly" leaves out a customer's saved cards and keeps Google Pay. It is not a card-only form.
  • When a card form is out of date because of a change on the checkout, vora.js reads the session again and loads the fresh form. Before, it retried for about 15 seconds, then the shopper had to reload the page.

1.49.0 — 2026-11-04​

Rolls out in stages, like every release; pin v1.48.0 if you need time to check your page first. Nothing changes for your integration.

Changed​

  • On a card update, the bank check pop-up (collection.openBankCheck()) now tells Von Payments what happened: it opened, the customer came back, closed it or moved to a new tab, or its time ran out. Each report is a short fixed code with the SDK version and the checkout session id. It never includes the bank's link or any card data. Set telemetry: false to turn it off. The pop-up's result is still only a hint: ask your server for the outcome.

1.48.0 — 2026-11-02​

Rolls out in stages, like every release; pin v1.47.0 if you need time to check your page first. Nothing changes for your integration today. If your page reads a card save's result, plan for the change below.

Added​

  • The embedded card form can now read a new answer from Von Payments' checkout, for when a payment is taken but the payment processor does not keep the card for later. The checkout does not send this answer yet, so a card save returns the same result as before. Once it does, collection.submit() reports the payment instead of an error. You get charged: true, a hold (chargeStatus: "succeeded", charged: false, paymentIntentId), or, while the payment is not confirmed yet, chargeStatus: "pending" with no charged value: wait for your charge.* webhook and do not charge again. There is no token, and setupForFutureUse is false when reuse was asked for. The checkout holds this answer back for now because versions before 1.48.0 read it as a failed card save, which would invite the shopper to pay again.

Security​

  • The optional bot check runs only with Von Payments' own verification keys. Its hidden frame now allows only the scripts and frames the verification service needs and sends no referrer. The bot check is still off for every account.

1.47.0 — 2026-10-30​

Rolls out in stages, like every release; pin v1.46.0 if you need time to check your page first. Nothing changes for your integration unless you call the new method below.

Added​

  • collection.switchSession(newClientSecret, { amount, currency }) keeps the card your shopper already typed when your checkout replaces its session (for example, when the cart total changes and your server creates a new session). Pass the total your page shows. A new session at any other total, or a form that already sent a card charge, answers not_switched. It resolves with a SessionSwitchResult:
    • { outcome: "switched", total }: the typed card now pays the new session, and the next payment pays exactly that total. If your form has a save-card box, it is unticked again.
    • { outcome: "not_switched", reason }: the card form is removed. Treat the old session as finished, then do what you do today: retrieve the new session and mount a new form. reason is for your logs.
  • To use it, your server creates both sessions with the same card_form_group. It works with separate card fields that charge when the shopper pays and do not use the in-page bank check. An embedded card form, wallet buttons, saved cards, or a form that uses that check, answer not_switched.
  • Until Von Payments switches the step on for checkouts, a call that gets as far as checkout answers not_switched with reason not_available, so your page keeps today's behaviour. Handle every not_switched reason the same way.
  • No Content Security Policy change: the method's code loads from https://js.vonpay.com, like the rest of Vora.js.

TypeScript: switchSession and SessionSwitchResult come with @vonpay/vora on npm, published once this release reaches every buyer.

1.46.0 — 2026-10-26​

Rolls out in stages, like every release; pin v1.45.2 if you need time to check your page first. Nothing changes for your integration unless Von Payments switches the bot check below on for your account.

Added​

  • An optional bot check on card payments and card saves, to slow down card-testing attacks. It is off unless Von Payments switches it on for your account, and while it is off nothing changes: nothing extra is downloaded and nothing extra is sent. When it is on, the check runs invisibly in a hidden frame from https://js.vonpay.com: your shoppers see no puzzle, no checkbox and no extra click, and it starts while they type their card so Pay is not slowed down. Wallet payments (Apple Pay, Google Pay) are not checked, and neither is the card form of a subscription card update (it charges nothing from the page).
  • Two new error codes, only possible when the check is on. Both mean nothing was charged and no card was saved:
    • frame_bot_check_failed: the payment could not be verified. Let the shopper press Pay again; every attempt runs a fresh check.
    • frame_bot_check_unavailable: verification is temporarily unavailable. Ask the shopper to wait about a minute before trying again.
  • If your page sets a Content Security Policy and the check is switched on for your account, add frame-src https://js.vonpay.com. Vora.cspSources() and csp.json list it under the bot-check feature.

TypeScript: the two error codes and the bot-check CSP feature come with @vonpay/vora on npm, published once this release reaches every buyer.

1.45.2 — 2026-10-23​

Rolls out in stages, like every release; pin v1.45.1 if you need time to check your page first.

  • Apple Pay and Google Pay: when no payment connection on your account accepts a payment, vora.js stops payment on the page. This takes effect once Von Payments' checkout sends that answer for a wallet tap, which starts in a later checkout release. The wallet buttons come down and the error (frame_provider_request_rejected, retryable: false) tells you this checkout session has ended: fix the cause, then start a new session. A later tap, or a submit() with a card typed into the form, gets the same error, and vora.js sends nothing. A saved card the buyer picks is still handed back; your server's charge of it is checked against the same account settings. vora.js charges nothing. Check the account's routing rules, or contact support with the request id. A card payment refused the same way carries retryable: false too and keeps its session. Other frame_provider_request_rejected errors are unchanged.

1.45.1 — 2026-10-22​

1.45.1 replaces 1.45.0, which was never rolled out to buyers. Coming from 1.44.1, read this section and the 1.45.0 section below: 1.45.1 carries everything in both. It rolls out in stages, like every release; pin v1.44.1 if you need time to check your page first.

  • One change a buyer can see: after leaving the bank check, the card is typed again (on businesses where the in-page bank check is switched on). When a buyer cancels the in-page bank security check (or presses Escape), or the check runs out of time, the card fields reload empty and the buyer enters the card again, so the next press runs a fresh bank check that only its own answer can complete. Keep your form on screen: the error is now retryable: true. A check that runs out of time is no longer reported as a pending payment. Nothing is charged by the cancelled check.
  • Passing the session id again keeps the client secret (only once your account has client secrets; until then nothing changes). After retrieve(clientSecret), a later retrieve() with the session id still sends the secret, so a page that retrieves again after an error keeps working. Our error messages now say "call retrieve() again with the same value you passed".
  • A client secret is sent only to Von Payments (only once your account has client secrets). If apiBaseUrl points anywhere other than Von Payments' own checkout, retrieve(clientSecret) is refused before anything is sent. Pass the session id there instead.
  • New error: frame_unexpected_redirect (only once your account has client secrets). A request carrying the client secret was answered with a redirect, which our API never sends. vora.js does not follow it or use the answer. If it was a payment, check its status on your server before the buyer tries again, then check apiBaseUrl and anything between your page and our API.
  • A saved card's expiry is still left out, never null, when it is unknown, on every kind of card form and on wallet payments.

TypeScript: the new error code and the 1.45.0 additions come with @vonpay/vora@1.45.1 on npm, published once this release reaches every buyer.

1.45.0 — 2026-10-21​

Coming from 1.44.1: everything that changes for you is in this section. It rolls out in stages, like every release; pin v1.44.1 if you need time to check your page first.

  • One change can alter what your page does: a failed Apple Pay or Google Pay tap. It used to arrive on the express-checkout element's change event as frame_binder_load_failed. It now arrives as frame_wallet_unavailable with a reason. Nothing was charged and the wallet buttons stay. If your page hides the wallet buttons on frame_wallet_unavailable, check reason first: with a reason, show your card form and leave the buttons, unless the reason is one that repeats (apple_session_refused, wallet_not_configured, google_merchant_error). The upgrade note under Changed has the full list.
  • A saved card's expiry is now in the submit() result. When a buyer saves a card, expMonth and expYear are there whenever the card's expiry is known. Keep the !== undefined check: they are still left out when it is not.
  • vora.sessions.retrieve() can take the session's client secret (only once your account has client secrets). Passing the session id keeps working exactly as before.
  • The in-page bank security check now works (on businesses where the in-page bank check is switched on). Nothing changes in your code.

TypeScript: the new WalletUnavailableReason type and the two new error codes come with @vonpay/vora@1.45.1 on npm (there is no @vonpay/vora@1.45.0), published once 1.45.1 reaches every buyer.

Added​

  • vora.sessions.retrieve() takes the session's client secret in place of its id (only once your account has client secrets). When your account gets client secrets, your server receives a clientSecret with each session (POST /v1/sessions): pass it to vora.sessions.retrieve() instead of the session id. Passing the session id keeps working exactly as before.
    • vora.js sends the client secret only to Von Payments' checkout, on every call for that session, and never stores it. session.id is still the session id.
    • Never put the client secret in a link or a URL, and never log it.
    • Two new error codes, neither worth retrying unchanged: frame_client_secret_invalid (the client secret is wrong, malformed or belongs to another session) and frame_client_secret_required (this session needs its client secret). Nothing was charged in either case.

Changed​

  • A failed Apple Pay or Google Pay tap is now reported as frame_wallet_unavailable, with a reason. When the buyer taps a wallet button in the express-checkout element and the wallet will not open or cannot continue, the change event's error was frame_binder_load_failed. It is now frame_wallet_unavailable ("this wallet can't be used here — show your card form") with error.reason. Nothing was charged and the buttons stay. frame_binder_load_failed now means only that the wallet buttons failed to load.
    • With reason a tap failed and the buttons stay: show the card form beside them. Persistent reasons (another tap fails the same way): apple_session_refused (common in apps' built-in browsers), wallet_not_configured (the merchant's Google Pay settings are missing), google_merchant_error. Transient reasons (another tap may work): apple_begin_refused, merchant_validation_failed, google_buyer_account_error, google_pay_error, unknown.
    • Without reason it is one of the cases the code already covered: no button visible or a currency wallets are not offered for (drop the wallet row), the payment provider refusing the wallet for your page, or a wallet save that came back unsaved (see 1.44.0). Show the card form in every case.
    • Upgrade note: a page that removed the wallet row on frame_binder_load_failed should not do that for frame_wallet_unavailable with a reason: show the card form and leave the buttons, unless the reason is persistent. A page that already treats every frame_wallet_unavailable as "no wallet here" keeps working, but hides wallets a buyer could have retried.
    • Types: new WalletUnavailableReason; ElementChangeEvent.error.reason is now ThreeDsRequiredReason | WalletUnavailableReason (was ThreeDsRequiredReason). Code that assigns it to a ThreeDsRequiredReason variable, or switches on it exhaustively, needs to check error.code first.

Fixed​

  • When a buyer saves a card, the result of elements.submit() now includes the card's expiry, expMonth (1-12) and expYear, as the field reference describes. Until now they were left out of that result even when the card's expiry was known, so a page could not show "expires 03/30" from it. This covers the card form, the separate card fields, and a wallet-only checkout read through submit(). As before, the two fields are left out (never filled with a made-up date) when the expiry is not known, so keep the !== undefined check. A result for a card that was charged, including one that was charged and saved, still has no expiry: the reply to a charge carries only the card brand and last four digits.
  • The in-page bank security check (3-D Secure) on card forms that charge when the buyer submits now runs. Before this fix the check never started, and the payment ended after the five-minute wait with nothing charged. The check now opens in its own window over your page as soon as the bank's step begins and closes when it ends. The same window is used when a card update asks for the bank's check before any charge. This applies only to businesses that Von Payments has switched on for the in-page bank check, and no business is on it in production today. Nothing changes in your code or in what submit() returns.

1.44.1 — 2026-10-20​

Coming from 1.43.2: this release contains everything listed under 1.44.0 below, plus the fix here. 1.44.0 reached a small share of buyers for under two hours on 2026-10-20 and was withdrawn before going further; its pinned URL keeps working. It rolls out in stages, like every release; pin v1.43.2 if you need time to check your page first.

TypeScript: the npm package @vonpay/vora@1.44.1 types this build. Its public types are the same as @vonpay/vora@1.43.2's apart from documentation (nothing added, removed or renamed). There was no @vonpay/vora@1.44.0 on npm.

Fixed​

  • A saved card whose expiry the payment provider did not return no longer shows a made-up date. expMonth / expYear are left out of the result for that card, as the field reference already says to expect (guard with !== undefined).

1.43.2 — 2026-10-18​

Coming from 1.43.0: this release is 1.43.0 plus the fix below, and it replaces 1.43.1, which was never rolled out to buyers. It rolls out in stages, like every release. If you pinned v1.42.0, v1.42.1, v1.43.0 or v1.43.1 and your card fields were affected, move your pin to v1.43.2.

TypeScript: the npm package @vonpay/vora@1.43.2 types this build. Its types are the same as 1.43.0's (this fix changes no type). There was no @vonpay/vora@1.43.0 on npm, so 1.43.2 is also the first npm release with the types 1.43.0 added, listed in the 1.43.0 section below.

Fixed​

  • Card fields could be hidden on pages that add their own padding or labels inside the card boxes, and the first fix changed some pages' look. Since 1.42.0 the built-in default look gave each card box (vora-card-number, vora-card-expiry, vora-card-cvc, the split card fields' containers and the security-code box) a fixed 44 px height and cut off anything taller, so on a page whose CSS put a label or padding inside the box the card input was pushed out of view and paying failed with provider_validation. 1.43.1 let the box grow but limited the card input to 42 px, which made the input shorter on pages that size their own boxes and set a min-height on the input. In 1.43.2 the boxes are at least 44 px tall and grow to fit what your page adds, without spilling onto the next row, and the card input is never limited: a page with no CSS of its own looks the same as in 1.43.0 (44 px boxes), a box you give a height or a min-height is filled as in 1.43.0, and only pages where 1.43.0 cut the input off look different (the input is now whole and clickable). Nothing changes in your Content-Security-Policy.

1.43.0 — 2026-10-16​

Coming from 1.42.1: everything that changes for you is in this section. It rolls out in stages, like every release.

TypeScript: there was no @vonpay/vora@1.43.0 on npm. @vonpay/vora@1.43.2 is the first npm release with this build's new types: ExpressCheckoutClickEvent, ExpressCheckoutCloseEvent and ExpressCheckoutAttemptOutcome (the express element's click and close events); collection.openBankCheck() with BankCheckOptions, BankCheckResult and BankCheckStatus; setupForFutureUse on vora.elements.create(), on submit() and on the express element; saveForFutureUse and walletChallenge on the express element; required on the save-for-future-use box; pendingReason on the submit result; the wallet-modal and bank-check Content-Security-Policy features; and the new error codes frame_save_consent_required and frame_other_payment_in_progress.

⚠️ Behaviour change — collection.submit({ setupForFutureUse }) now saves the card. In 1.42.x, passing setupForFutureUse to submit() was ignored with a console warning. From 1.43.0, submit({ setupForFutureUse: "off_session" }) (or true) is read as the buyer's agreement that the card may be charged again later, when no save-for-future-use box is mounted: the card is saved for later charges whenever the checkout session names a buyer. A guest's card is never saved; a guest pays a normal one-time payment. If your page passes it on every pay press and the wording next to your pay button is not that agreement, remove it before this version reaches you, or pin v1.42.1. When a box is mounted, the box decides: an unticked box is never overridden. allowRedisplay, displayScope, savedCardDisplayScope and setupForFutureUse: false on submit() are still ignored, as before.

Added​

  • Your own checkout wording as the buyer's save consent. For a page whose wording next to the pay button is the buyer's agreement (the price, how often, any trial, how to cancel): vora.elements.create({ setupForFutureUse: "off_session" }) saves the card on every card and Apple Pay / Google Pay payment of that collection, and submit({ setupForFutureUse: "off_session" }) does it for one payment. Nothing is greyed out. The result says whether the card was actually saved. An unknown value on elements.create() is refused when the collection is created.
  • Apple Pay / Google Pay carry the buyer's save consent. A ticked save-for-future-use box in the same collection as express-checkout now saves the wallet card too, exactly as for a typed card; a page that runs card and wallet on two sessions passes the box with create("express-checkout", { saveForFutureUse: box }). Or use your own wording: create("express-checkout", { setupForFutureUse: "off_session" }). The wallet result reports setupForFutureUse: true when the card was saved, false when it was charged but not saved (a guest). ⚠️ A page that already has a box and wallet buttons in one collection now saves the wallet card too when the box is ticked.
  • A required save box (required: true on save-for-future-use), for a subscription whose renewals need the saved card. Its change.complete is the tick. submit() with a new card and the box unticked is refused before anything is sent, with the new error code frame_save_consent_required (retryable), and the box asks the buyer to tick it. The wallet buttons stay visible but greyed out, and a tap asks for the tick instead of paying.
  • Apple Pay / Google Pay bank check in a modal, preview (walletChallenge: "modal" on express-checkout). When a wallet payment needs a 3-D Secure check, the bank's page opens in a modal on your page instead of a full-page redirect. Off by default ("redirect", unchanged). confirm fires once, after the check: succeeded only once the payment is confirmed, otherwise pending, with a new optional pendingReason ("challenge_closed", "challenge_failed" or "challenge_unconfirmed") so you can word your message; hold the order for your webhook. A check the buyer closes or that fails is never reported as "nothing was charged" on its own, because the bank may still approve a moment later. When the buyer presses Cancel and the checkout confirms that nothing was charged, the element reports the new code frame_3ds_challenge_cancelled (retryable when the buyer may tap again or pay by card); until the checkout supports that confirmation, Cancel ends as pending with pendingReason: "challenge_closed". The element falls back to the full-page check when your Content-Security-Policy refuses the modal (new CSP feature wallet-modal in csp.json / cspSources()), when your page is inside another site's frame, or when the modal cannot load. It downloads only on a page that turns it on.
  • Card update: the bank check in a pop-up, collection.openBankCheck(). On a card-update page (a collect-only session), when your server's card update answers that the bank must check the card, pass that answer's securityCheck object to collection.openBankCheck(). The bank's page opens in a pop-up on your page, with a link to open it in a new tab instead, and closes once the check's time is up. It resolves with a hint — returned, closed, opened_in_new_tab or expired — never a result: ask your server, which asks the checkout. { signal } and unmount() close it. An object with no usable link is refused with frame_3ds_required and no pop-up. It downloads only when called. New CSP feature bank-check in csp.json / cspSources().
  • Apple Pay / Google Pay: the buyer can tap again after a decline on a page with no card form. When a wallet payment is declined and the checkout keeps the session open, the express-checkout element now reports the decline as retryable: true with attemptsRemaining and leaves the wallet buttons up, instead of ending the session. Nothing was charged; the message no longer suggests paying with a card on a page that has none. A decline that ends the session, or no attempts left, still ends it, as before.
  • Express checkout: click and close events. expressCheckout.on("click", ({ wallet }) => …) fires when the buyer taps an Apple Pay or Google Pay button, synchronously and before the sheet can be approved, on every payment connection that offers them, including those that draw the buttons inside the payment provider's own frame (where a click listener on your container hears nothing). expressCheckout.on("close", ({ wallet, outcome }) => …) fires exactly once after each click, when that attempt is over, and says how: outcome is "succeeded", "unresolved" (the payment can still complete: keep the order held for your webhook), "tokenized", "failed" or "cancelled". It never fires while an approved payment is still being charged. New types ExpressCheckoutClickEvent, ExpressCheckoutCloseEvent and ExpressCheckoutAttemptOutcome.

Changed​

  • Express checkout: the card form is locked from the wallet approval. A card submit() on the same collection is refused with frame_session_not_ready, nothing sent, from the moment the buyer approves the wallet sheet (before your onConfirm runs) until the wallet result is known. Before, it was refused only once the wallet charge itself had started.
  • Apple Pay / Google Pay buttons drawn in your page ignore clicks made by a script (button.click()), which could not open a wallet sheet anyway, and a second Apple Pay tap while its sheet is opening.
  • The deprecated vora.fields.create("card") field downloads its tokenize() step separately. It comes from the same CDN, at the same version as vora.js, when you call vora.fields.create(), so vora.js itself is about 1.1 kB (gzipped) smaller on every page. tokenize() waits for it only if it has not arrived yet. If it cannot be downloaded, tokenize() returns { error } with frame_binder_load_failed and nothing is sent. Results and error codes are otherwise unchanged; vora.elements is not affected.

Fixed​

  • A checkout session that ended while a payment was being decided is no longer reported as "not charged". When the checkout says the session ended mid-payment and does not confirm that nothing was charged, the card form and Apple Pay / Google Pay now report pending (wait for your payment webhook). Where no payment is being reported (for example loading the card form), the error is frame_other_payment_in_progress instead of frame_session_expired ("nothing was charged"). Before, the buyer could be told "not charged" while a charge was still landing. A session that ended with nothing in progress is reported as before.
  • "Another payment is still running" is never reported as a success or a failure. When the checkout answers that a different payment on the same session is still in progress (for example a wallet bank check), a card charge or wallet payment now waits for that payment and reports its outcome (succeeded, or pending while it runs). Anywhere else, for example a card save, it is the new error code frame_other_payment_in_progress (not retryable): wait, and do not start another payment or a new session. Before, the card charge could read it as an earlier success, and other paths as a generic failure.
  • Express checkout: submit() from the element's own change handler. Calling the collection's submit() from the express-checkout element's change handler (on complete: true) to read the wallet's token was refused with "A wallet payment is already in progress for this checkout". It now returns the wallet's result.
  • Apple Pay / Google Pay: no second payment after the checkout is paid. Once a card payment or a wallet payment has succeeded on a checkout session, a further wallet tap is refused before anything is sent, with the same frame_session_not_ready error ("A payment was already placed on this checkout") the card form already gave.
  • Pinned URLs for a version that was never published (for example a mistyped https://js.vonpay.com/v1.99.0/vora.js) still return 404, now with Cache-Control: public, max-age=60. Published versions are unchanged.

Security​

  • @vonpay/vora: a pinned load only uses code the browser checked against the pinned hash. With loadVora.setLoadParameters({ pin: true }), a window.Vora already on the page is used only when every vora.js <script> tag on the page is the pinned URL with the same integrity hash. A window.Vora left by the auto-updating /v1/vora.js tag, or one with no vora.js tag behind it, now rejects with version_mismatch even when its version matches, instead of being used without the integrity check. Unpinned loads are unchanged.
  • js.vonpay.com responses carry X-Content-Type-Options: nosniff, and https://js.vonpay.com/v1/vora.js is served Cache-Control: private, max-age=300 with Vary: Origin, User-Agent. Browsers still keep it for 5 minutes; a shared proxy no longer keeps one copy for everyone behind it, so each browser gets its own share of a staged rollout. Pinned URLs and the other files keep their caching.
  • Hardening: vora.js now checks the payment provider's account identifier it receives when loading the card fields, and refuses one that could point the card fields at a different web address. It fails with the existing frame_binder_load_failed error, as for a missing value. No change for a correctly configured checkout; no change to the API.

1.42.1 — 2026-10-15​

1.42.0 was withdrawn. It was rolled back during its staged rollout on 2026-10-15, and every checkout is back on 1.40.2. 1.42.1 includes everything in 1.42.0 (listed below, with 1.41.0) plus the fix in this section. Coming from 1.40.2, read this section and the 1.42.0 section. If you pinned v1.42.0, move your pin to v1.42.1.

TypeScript: the npm package @vonpay/vora@1.42.1 types this build. It includes 1.42.0's SubmitResult as three shapes told apart by status, { status: "card_collected" } among them (see the 1.42.0 section).

Fixed​

  • A card-save option passed to collection.submit() no longer blocks payment; it is ignored with a console warning, as in 1.40.2. To save a card for reuse, use the save-for-future-use element. A future major version will refuse the option. This covers setupForFutureUse, allowRedisplay, displayScope and savedCardDisplayScope (camelCase or snake_case). In 1.42.0, passing one of them made submit() return frame_field_validation_failed without taking the payment. The option is never read as the buyer's consent, so a card saved this way cannot be charged again later. vora.js also reports to Von Payments that the option was passed (unless you set telemetry: false), so we can tell you before that major version.

1.42.0 — 2026-10-14​

Coming from 1.40.2? Everything that changes for you is listed in this section, including the one addition first cut as 1.41.0, which was never released to buyers. If you pinned v1.41.0, move your pin to v1.42.0.

⚠️ Visible changes — check your page before this version reaches you. Two changes alter how the elements look. Nothing about payments, requests or results changes.

  1. A built-in default look on every page, even one that passes no style or theme. The card fields, the saved-card security code, the email, name and address fields, the country menu and the save-my-card tick now get a standard bordered look: 44 px full-width fields, the combined card element as a grid (number on top, expiry and CVC side by side), the address fields in a row when there is room, a blue focus ring and a red border on an invalid field. Your CSS always wins, in a cascade layer or not: plain rules, @layer rules (Tailwind v4 classes included), style and theme all override the defaults. So a blanket CSS reset also removes our borders and padding, as on 1.40.2: style our fields as you style your own inputs. If you drew a border on a wrapper around the element's container, you now see two borders. Browsers without constructed stylesheets (Safari before 16.4) keep the previous look. Details under Changed below.
    • Content-Security-Policy, optional: vora.js adds one line, <style>@layer vora-defaults;</style>, so that your layered CSS can win. Only if your policy does not already allow inline styles ('unsafe-inline', or a nonce shared with your scripts) add 'sha256-OuajJxe804doBGkJvwnBjnP1cpvNWFjHltumC6RbkcA=' to the directive that governs <style> elements; never add it next to 'unsafe-inline', which a hash switches off. Without it the look still applies and your plain CSS, style and theme still override it; only your layered CSS does not.
  2. style and theme now also style the elements drawn into your page (email, cardholder, address, payment-method-picker, saved-methods and save-for-future-use), and those inline values take precedence over your page's own CSS for the same properties. A page that passes its card styles to save-for-future-use (or a collection theme written for the card fields) now sees the save-my-card checkbox label rendered as a bordered, padded box. To keep the old look, pass the style to the card elements only, or override it per element.

We ship both in a minor release on purpose: they change only how the elements look, and your CSS or a per-element style can undo either.

⚠️ One set of Apple Pay / Google Pay buttons per checkout. A second express-checkout element mounted while the first is live is now always refused with frame_binder_load_failed. If you show the buttons in two places (for example a mini-cart and the checkout page), unmount the first before mounting the second (details under Changed below).

Changed​

  • A standard look out of the box. Card number, expiry, CVC and the saved-card security code now sit in 44 px bordered boxes (they could render 150 px tall and borderless on a page that did not size them); the email, name and address fields and the country menu are full width, 44 px tall and bordered, in your page's font at no less than 16 px; the address puts city, state and postal code side by side when there is room; the combined card element puts the number on top and expiry and CVC side by side; the save-my-card tick is 20 px. Focus shows a blue ring, an invalid field a red border. Input text is a fixed dark colour on the white field, so it stays readable on a dark page.
    • Your CSS always wins, in a cascade layer or not: every default has zero specificity (:where()) and sits in the cascade layer vora-defaults, which vora.js declares first on your page with a one-line <style>@layer vora-defaults;</style>. So plain rules, rules inside your own @layer (Tailwind v4 classes such as p-0 or border-0), style and theme all override it, with no !important.
    • Any page CSS, layered or not, beats the built-in defaults; a blanket reset therefore also removes our borders and padding, as on 1.40.2. With Tailwind v4 and no classes on our fields, its preflight removes the inputs' border, padding, rounded corners and white field and the card boxes' border (they keep their corners and white field); Tailwind v3's preflight or a plain * { padding: 0; border: 0 } removes the inputs' border and padding and the card boxes' border. The 44 px height, width, layout and focus ring stay. Style our fields as you style your own inputs.
    • Content-Security-Policy: nothing to change if the directive that governs <style> elements (style-src-elem, else style-src, else default-src) allows 'unsafe-inline', uses a nonce shared with your scripts, or is not set. Otherwise add 'sha256-OuajJxe804doBGkJvwnBjnP1cpvNWFjHltumC6RbkcA=' to it so your layered CSS can override the look; only if that directive has no 'unsafe-inline' (a hash switches it off). Without it the browser reports one refusal per page (to your report-uri too, if set), the look still applies, and your plain CSS and style / theme still override it. It is listed under ifNoUnsafeInline in csp.json.
    • ⚠️ If you drew a border on a wrapper around the element's container, you now see two borders: move your border onto the container, or remove ours with .vora-field { border: 0 }.
    • Not affected: the older vora.fields.create("card"), the full embedded payment form and the hosted checkout.
  • style and theme now apply to the elements drawn into your page — email, cardholder, address, payment-method-picker, saved-methods and save-for-future-use. They used to accept these and ignore them. Now they style the inputs, rows and checkbox label they draw: font, text, placeholder and error colours, padding, border, backgrounds, the selected row's border and the tick colour (color.accent), the focus ring and row hover. The address fields have no visible labels, so color.label does not apply there.
    • If you pass neither style nor theme, nothing is written inline: these elements get only the built-in default look above, which any CSS of yours overrides.
    • ⚠️ A collection theme styles these elements too. If your theme was written for the card fields (padding, border, background), the save-my-card checkbox label, for example, now gets that box. Keep the old look by passing the style to the card elements only, or override it per element (style: { spacing: { padding: "0px" }, border: { width: "0px" } }).
    • Works under a strict Content-Security-Policy with no change: no 'unsafe-inline', no nonce. Values outside the allowed colours and sizes are refused at create(), as on the card fields.
  • With a wallet button and a card form in the same vora.elements collection, once a wallet payment succeeds (charged, or authorised and held on manual capture) a later card submit() is refused before anything is sent: frame_session_not_ready, retryable: false, "A payment was already placed on this checkout". Before, the card form sent a second request that the checkout refused. A cancelled, declined, failed or still-pending wallet payment, or one waiting for 3-D Secure, leaves the card form usable. A collection with only a wallet still reports the wallet's outcome from submit().
  • A payment on a checkout now locks every vora.elements collection on that checkout session, not only the one it was made in: a second vora.elements.create() for the same session refuses a card submit the same way. A different session is unaffected.
  • A successful card charge when the buyer presses Pay (charged, or authorised and held) now locks the checkout too. ⚠ A repeated Pay press after a successful charge resolves frame_session_not_ready (retryable: false, nothing sent) instead of returning the first result again: keep the first submit() result, or read the payment with your secret key. A pending charge or a 3-D Secure step locks nothing. See "One payment per checkout" in the README; it also notes that the older vora.fields card API is not covered (it only saves a card) and that a page script that edits the object vora.sessions.retrieve() returns can make a result wrong, though not take a second payment.
  • After a payment on the checkout (a succeeded wallet payment, or the embedded card form's own payment), choosing a saved card and calling submit() returns the same refusal instead of the saved card's id, so it is not charged as a second payment.
  • collection.submit() no longer ignores a card-save consent option. Passing submit({ setupForFutureUse }) (or allowRedisplay, displayScope, savedCardDisplayScope, in camelCase or snake_case) now returns frame_field_validation_failed and sends nothing. Before, the option was dropped without a word, so the card was saved with no consent to charge it again and later charges on it were refused. With vora.elements, the buyer's consent comes only from the save-for-future-use element: mount it, and its tick is sent with the card. Any other option submit() does not read now logs one console warning naming it, and the submit goes ahead.
  • TypeScript types: collection.submit() now returns SubmitResult as three shapes. When chargeStatus is "requires_action", redirectUrl is always a string, so the 3-D Secure redirect compiles under strict without a ! or a cast:
    const result = await collection.submit();
    if (result.chargeStatus === "requires_action") {
    window.location.href = result.redirectUrl; // nothing has been charged yet
    }
    This changes types only; the SDK behaves exactly as before. The shapes are exported as SubmitResultRequiresAction, SubmitResultNoAction and SubmitResultCollected ({ status: "card_collected" } and nothing else), with the shared fields on SubmitResultFields. Reading any field compiles as before. If your code declares interface X extends SubmitResult, extend SubmitResultFields instead; a test fixture typed SubmitResult with chargeStatus: "requires_action" now needs a redirectUrl.
  • The card form Von Payments opens to replace a card already on file (see Added below) resolves { status: "card_collected" }, not the { status: "collected" } that 1.41.0 (never released to buyers) used, so the value no longer reads like the saved-card security-code field's "collected", which means something different. That form is also refused when its checkout carries an amount. Nothing changes for sessions you create.
  • ⚠️ One set of Apple Pay / Google Pay buttons per checkout. A second express-checkout element mounted while the first is live is now always refused with frame_binder_load_failed (it sometimes loaded before, depending on timing). Unmount the first element before showing the buttons somewhere else.

Added​

  • SubmitResult.status — "card_collected" on a card form that Von Payments opens to replace a card already on file: submit() puts the card into the session and does nothing else (no card is saved and nothing is charged from the browser); Von Payments finishes the change server-side. On that form the result carries only status, and wallet buttons, the save tick and saved cards are not offered. The value never appears on a session you create, so nothing changes for your integration. It never means "paid" or "saved": read the outcome on your server.
  • The save-my-card checkbox (elements.create("save-for-future-use")) now tells your page whether it is ticked: its change event carries checked: true or false. Use it to keep your pay button disabled until the buyer ticks the box when your checkout needs a saved card (for example a subscription). It only reports the tick; it cannot set it, and the box still always starts unticked.
  • vora.securityCode(): your container now gets the same CSS classes as every other field — vora-field and vora-field--security-code when it mounts, vora-field--focus while the buyer is in the field, vora-field--invalid once they leave a code that is not valid, and vora-field--complete when the code is valid. They are removed on unmount(). Styling only: call submit() to check the code.
  • vora.securityCode(): on test keys, the first submit() on a page logs one console note: the browser's confirmation of the code is not a fraud control, and for the card issuer's check you create the payment with securityCodeVerification: "strict". Never shown on live keys.
  • FrameError.declineCode: on a declined card charge (frame_payment_declined), the reason as a fixed code your page can branch on instead of reading the message — the same name as declineCode in the server SDKs. "authentication_not_completed" means the buyer did not finish their bank's security check (3-D Secure): nothing was charged and the same card can succeed, so do not send them to a different card. Any other value is a real decline. Absent when the checkout sent no code or one this version does not know (an unknown value is never passed through), and on wallet, embedded-form and card-save declines. The error code is unchanged, so existing handling keeps working. New exported type: ChargeFailureCode.

Fixed​

  • A bank security check (3-D Secure) that the buyer was sent to and did not finish is no longer described as a decline. The charge reports it as authentication_not_completed; the error is still frame_payment_declined, but its message now says the payment was not made because the check was not completed and that nothing was charged, and it never tells the buyer to use a different card: the same card can succeed once they complete the check (unless their bank said not to try the card again).
  • With a wallet button and a card form in the same vora.elements collection, a card submit no longer reports the wallet's earlier tap. Before, a wallet payment that asked for 3-D Secure and that the buyer did not complete (with handleRedirect: false) was still in a later card result, as chargeStatus: "requires_action" with the wallet's old challenge link, so redirecting on it sent the buyer to a dead page. A result now carries only the card that was submitted, or the saved card that was chosen. A collection with only a wallet still reports the wallet's outcome.
  • vora.securityCode(): the element you mount it into now stays in your page. Before, the field replaced that element with one of its own (copying its class and id), so a reference you kept to it pointed at an element no longer on the page, and after unmount() a leftover element stayed behind. unmount() now removes everything the field added and leaves your element as it was.
  • vora.securityCode(): unmount() no longer throws when the card fields report no hidden controller frame.
  • Apple Pay / Google Pay buttons no longer appear after you unmount them while they are still loading. If your page removed the express-checkout element (or unmounted the collection) before the buttons finished loading, they could still appear, and a payment made with them reached none of your handlers. A late load after an unmount is now discarded, and so is one that finishes after a declined payment ended the checkout.
  • A wallet payment approved just as you unmount is no longer charged. If the shopper approved the Apple Pay / Google Pay sheet but your page unmounted the element before the charge was sent (for example while your onConfirm was still running), the sheet is now told the payment failed and nothing is charged. A charge that was already sent cannot be recalled: rely on the payment webhook for it.
  • mount() on the express-checkout element is refused after an unmount, and while a first mount() is still loading. A second mount in that window used to leave an extra set of buttons on the page.
  • Unmounting the express-checkout element and creating a new one straight away now works (for example under React StrictMode in development). The new element used to fail to load its buttons with frame_binder_load_failed.
  • Wallet buttons (expressCheckout): when the bank asks the buyer to authenticate (chargeStatus: "requires_action"), the result now includes paymentIntentId, as the other wallet outcomes already did. Use it to match the payment to your order, for example with handleRedirect: false on a manual-capture session. Nothing has been charged or authorised at this point, and the id reached you through the buyer's browser: wait for the charge.* webhook, then read the payment with your secret key and check its status and metadata.session_id before you capture, void or fulfil.
  • Card form (vora.elements with card, or card-number / card-expiry / card-cvc): when the bank asks the buyer to authenticate (chargeStatus: "requires_action"), submit() now includes paymentIntentId too, when the checkout names the payment. The same applies: nothing has been charged or authorised yet, and the id came through the buyer's browser, so wait for the charge.* webhook, then read the payment with your secret key and check its status and metadata.session_id before you capture, void or fulfil. If the buyer does not finish the check, that payment never completes, and paying again can create a different one: act on the payment the webhook names.

Security​

  • Hardening: the address, key and network function vora.js sends its requests with are now fixed when new Vora() runs, and other scripts on the page cannot change them. Editing the config object you passed to new Vora() afterwards no longer has any effect. No change to the API; you can still add your own properties to the Vora object or extend it.

Documentation​

  • "PCI scope" in the README now notes that the card fields' focus and validity marks (vora-field--focus / vora-field--invalid, and the payment provider's own marks they mirror) are visible to every script on your page. They never carry card data.

1.40.2 — 2026-10-11​

Coming from 1.39.1? This release includes everything in 1.40.1 and 1.40.0 (listed below), plus the changes in this section. Neither 1.40.1 nor 1.40.0 was released to buyers; if you pinned v1.40.0 or v1.40.1, move your pin to v1.40.2.

Changed​

  • vora.securityCode(): after the payment provider accepts the code, submit() now also tells Von Payments that a valid code was entered, and resolves { status: "collected" } only once that is recorded. The request carries no code and no card data. Charge from your server only after submit() resolves. A charge with a security code session that was not confirmed this way is refused with 422 security_code_not_collected, so older versions of vora.js cannot complete this flow: use 1.40.2 or later.
  • If the confirmation cannot be delivered (network, service busy), it is retried a few times; if it still fails, submit() rejects with frame_tokenization_failed and the buyer can submit again. A session that is already used or expired rejects with frame_session_expired (open a new one on your server), an unknown one with frame_session_not_found. On any rejection nothing was charged; do not charge with that session.

Fixed​

  • Documentation only: on the card fields of an integrationMode: "elements" session, a card whose number and expiry date are filled in but whose security code was never entered also counts as incomplete: change reports complete: false and collection.submit() returns frame_field_validation_failed without sending anything. This is unchanged from 1.40.1.

1.40.1 — 2026-10-11​

Not released to buyers: replaced by 1.40.2, which includes everything listed here.

Coming from 1.39.1? This release includes everything in 1.40.0 (listed under 1.40.0 below), plus the changes in this section. 1.40.0 was withdrawn during its staged rollout and replaced by 1.40.1; if you pinned v1.40.0, move your pin to v1.40.1.

Security​

  • Hardening for the card fields of an integrationMode: "elements" session (card, card-number, card-expiry, card-cvc) and the saved-card security-code field (vora.securityCode()): before they load, they now check a page setting that controls where they load from, and lock it for the rest of the page. If something on the page has changed it, the fields do not load: mount() throws (the security-code field emits error) the new code frame_page_tampered, no card field is created, and nothing is charged. This code is reported even on live keys. Pages that do not touch that setting see no change. As defence in depth we recommend a Content Security Policy frame-src that lists only the hosts in the published CSP list (see "PCI scope" in the README).

Fixed​

  • The card fields of an integrationMode: "elements" session (card-number, card-expiry, card-cvc, and the combined card) no longer send a card the form reports as not valid. When the card number or expiry date is missing or invalid (for example a number that fails the checksum, shown with vora-field--invalid), or the security code is invalid, collection.submit() returns { error: { code: "frame_field_validation_failed" } } and sends nothing: the card is not saved and nothing is charged. The buyer can correct the card and press Pay again. Until now such a card could be saved, and a charge of it was then declined. The embedded card form already worked this way.
  • On the embedded card form, the change event now reports complete: true only once the card details are valid, and complete: false again if they become invalid. Until now it reported complete: true as soon as the form loaded, even for an empty card or a mistyped number. The vora-field--complete class follows the same rule. If you enable your Pay button on complete, it now stays disabled until the buyer finishes a valid card.
  • vora.securityCode(): submit() now sends only a security code the field reports valid. A field left empty, or an invalid code, rejects with frame_field_validation_failed and nothing is sent; the session is not used up, so the buyer can enter the code and submit again. Until now an empty field could be submitted as collected, and a charge with that session then went ahead without a security code.

Changed​

  • On those card fields, pressing Pay with the form still empty now returns frame_field_validation_failed at once, instead of frame_tokenization_failed after a request.

Added​

  • New error code frame_page_tampered: the card fields, or the saved-card security-code field, did not load because something on your page changed where they load from. It is raised by mount() (the security-code field emits it as error) before any field is created, so no card data could be typed or sent and nothing was charged. Find and remove the script or page element that sets it (for example a tag-manager tag, a browser extension, or injected HTML), then reload; retrying on the same page fails the same way. This is not a buyer problem. It is reported even on live keys.

1.40.0 — 2026-10-09​

Withdrawn on 2026-10-11 during its staged rollout and replaced by 1.40.1, which includes everything listed here.

Fixed​

  • The card fields of an integrationMode: "elements" session (card-number, card-expiry, card-cvc, and the combined card) now get vora-field--focus while the buyer is in the field, and vora-field--invalid once the buyer leaves a field whose value is not valid (until it is fixed). Until now only vora-field--complete was set on them. The combined card gets --focus while any of its three fields has focus. A field left empty after the buyer was in it also counts as not valid. Their focus, blur and change events are unchanged.
  • If the payment provider's card fields fail while a card element (card, card-number, card-expiry, card-cvc) is being mounted, mount() now throws frame_binder_load_failed and your element is left as it was: what was added to it is removed and the vora-field classes come off. Until now the element kept an empty card box and mount() threw the provider's own error. Nothing is charged. The form is released: the other elements of that vora.elements.create() form are taken down too, and creating a new card form before you retrieve the session again throws frame_session_not_ready. Call vora.sessions.retrieve(sessionId) again, then create and mount a new form.

Changed​

  • vora.sessions.retrieve() now waits when the card form is briefly not available, instead of failing at once. That happens while a payment on the session is still being processed (usually a few seconds), or while a fresh card form is prepared after a declined attempt. It asks again about once a second for up to about 15 seconds. It only ever asks for the card form again; it never sends a payment.
  • A session that has ended after its last allowed attempt now gives frame_session_expired at that step, at once.

Added​

  • New error code frame_payment_in_progress (retryable: true): a payment on this session was still being processed after the wait. Tell the buyer to wait; do not start another payment or a new session. Retrieve the session again in a few seconds, or wait for your payment webhook.
  • New error code frame_payment_form_not_ready (retryable: true): the fresh card form was still being prepared after the wait. Nothing was charged; retrieve the session again in a moment.

Documentation​

  • With showIcon: true, the card-brand icon appears once the buyer has typed enough of the card number for the brand to be detected. No icon is shown before that.

1.39.1 — 2026-10-09​

Fixed​

  • Separate card fields (card-number, card-expiry, card-cvc) on sessions created with integrationMode: "elements": the field is now placed inside the element you mount it into. Until now the payment provider swapped that element out of the page for one of its own, which copied its classes. As a result:
    • after a declined card that leaves the payment open, or when an expired card form was rebuilt, the separate card fields came back empty: the buyer could not type a card. The combined card element came back twice (three old boxes plus three new ones);
    • after collection.unmount(), a new form mounted into the same elements (passed as elements, not selectors) showed no separate card fields, and the combined card again showed six boxes;
    • vora-field--complete was set on an element that was no longer in the page;
    • with showIcon: true the card-number box got an inline display: inline-flex and stopped filling its row. Your element now stays in place with no inline style, and the brand icon stays inside it.
  • Creating a new form from the same Vora after collection.unmount() failed when the form was mounted, with a message about the session's payment provider. It now fails when the card element is created (collection.create("card"), create("card-number"), …) with frame_session_not_ready, and the message tells you what to do: call vora.sessions.retrieve(sessionId) again, then create the new form.
  • A card field is an iframe, which takes its height from your box: give the box a height (for example 44px), not only a min-height, or the field is drawn at the browser's default of 150px. The README's starting CSS now does this.

Added​

  • Content Security Policy: font-src https://applepay.cdn-apple.com for Apple Pay, for test and live keys. Apple Pay JS loads fonts from there; a policy without it blocks them.
  • https://js.vonpay.com/v1/csp.json: the list for the auto-updating script. During a staged rollout it covers both versions a buyer may be served. If it does not answer 200, keep sending your last list.

Known limitation​

  • On the card fields of an integrationMode: "elements" session, vora.js sets vora-field, the type class and vora-field--complete (on all the card fields at once, when the whole card is complete). It does not set vora-field--focus or vora-field--invalid on them. Show a card error from the result of collection.submit().

1.39.0 — 2026-10-08​

Added​

  • vora.securityCode({ session }): a single field that asks the buyer to re-type the security code of a card you have saved, for a payment they are present for. Your server opens the session (POST /v1/security_code_sessions) and, once submit() resolves, charges with security_code_session. One per page and single use: after any charge, open a new session. The code goes straight to the payment provider and never reaches your page or your servers. Not available until it is enabled for your account.
  • New error code frame_card_form_conflict: the security-code field refuses to start on a page that already has a card form, because only one can run per page.
  • Each version now publishes the Content Security Policy sources it needs, for test and live keys, at https://js.vonpay.com/v<version>/csp.json, and Vora.cspSources({ mode: "live" }) returns the same list in the browser. Each source names the feature that needs it, so you can leave out what you do not use. The README's Content Security Policy section has a copy-paste policy for each mode.

Changed​

  • Outside Safari, Apple Pay JS (https://applepay.cdn-apple.com) is now loaded only by the full payment form. Pages with card fields or the express-checkout element no longer load it. The express-checkout element offers Apple Pay in Safari only.
  • A declined card no longer names which card detail was wrong, or that the card has been flagged. On sessions created with integrationMode: "elements" that charge at submit, a wrong security code, postal code or expiry date is reported as incorrect_card_details, and error.message reads "The payment was declined (incorrect_card_details). Check the card details, or use a different card." followed by the usual retry instruction. A flagged card (and a refusal by one of your own rules) is reported as card_declined. Naming the detail would tell someone trying stolen card numbers which details are right. (On the default embedded payment form a decline is always reported as frame_payment_declined with "The payment was declined.", with no code.) The exact reason still reaches your server on the charge.failed webhook (decline_code). retryable and the rest of the decline are unchanged.

Deprecated​

  • avsResultCode and cvvResultCode on the submit() result, and the AvsResultCode / CvvResultCode types. The address and security-code match results are no longer returned to the browser, for the same reason, so these fields are always absent. Read avs_result_code and cvv_result_code on your server from the charge.succeeded / charge.failed webhook. The fields stay in the types, so existing code keeps compiling.

Fixed​

  • Embedded card form (embed sessions): a declined card is reported as a decline, and a second Pay can no longer start another payment on a finished session. A decline now returns frame_payment_declined (it was frame_tokenization_failed). Whether the buyer can try again is decided by Von Payments, never assumed:
    • retryable: true: the checkout re-opened the session for another card, and the card form has already been reloaded with a fresh form. Show the message and let the buyer enter a card; do not create a new session. attemptsRemaining says how many tries are left when known.
    • retryable: false: the session has ended. Start a new session for the buyer to pay again. A further collection.submit() on that checkout is refused before anything is sent. Retrying on the same session is switched on per account by Von Payments.
  • Embedded card form: a connection failure is not reported as a failed payment straight away. The SDK asks Von Payments what happened. If nothing reached the payment provider, you get frame_tokenization_failed ("Nothing was charged; the buyer can try again") and the same form can be used again. If a payment went through or is still being processed, collection.submit() returns that result (recovered: true) and a second submit on that checkout is refused.
  • vora.sessions.retrieve() waits (about a second at a time, up to 30 seconds) while a payment on the session is still being processed, instead of showing a card form that was already used. If it is still in progress after that, it throws frame_session_not_ready: retrieve the session again in a moment.
  • When a payment needs 3-D Secure (chargeStatus: "requires_action"), the result now carries the card the payment was made with (last4, brand). It used to show "0000" / "unknown" on the card form and leave the card out on the express-checkout element.
  • The embedded card form now reports American Express, Diners Club and UnionPay cards by brand (amex, diners, unionpay) when a guest pays or a payment is held, instead of "unknown".
  • Saving a card no longer fails when Von Payments does not return the card's brand or last four digits: they read "unknown" and "0000", as everywhere else.
  • The embedded card form now refuses a repeat payment on the same form — for example a double click, a reload of the form, or a second try after a lost reply — with the same frame_session_not_ready answer collection.submit() already gives. Paying again with another card still works when Von Payments re-opens the session for it. This protects against accidental repeats; it does not stop code you run on your own page from starting a new payment.

Planned for the next major version​

  • last4, brand, expMonth and expYear on payment results will be null when the card is not known, instead of the placeholders "0000" and "unknown" used today. If you show these fields, be ready for null then. Nothing changes in 1.x.

1.38.1 — 2026-10-05​

1.38.1 is the first release of the 1.38.0 changes below. 1.38.0 was never rolled out on https://js.vonpay.com/v1/vora.js (it was only available at its pinned URL), so 1.38.1 includes everything listed under 1.38.0 plus these two fixes: when the auto-updating URL moves from 1.37.0 to 1.38.1, you get both. If you pinned v1.38.0, move to v1.38.1.

Fixed​

  • When the bank declines a card on its 3-D Secure page and the checkout re-opens the session for another card, the buyer's next card is now charged. Previously the first submit after the buyer came back was answered with the earlier decline, the new card was never sent to the bank, and collection.submit() returned frame_payment_declined with retryable: false. Nothing changes for a payment with no earlier decline. Correction (2026-10-08): this holds when the buyer's page loads after the checkout has re-opened the session. If the buyer comes back sooner, the new card can still be refused until the page is reloaded; a later release recovers from this on the page without a reload.
  • The deprecated card.tokenize() now reports a hold (a session created with captureMethod: "manual") the way collection.submit() does: chargeStatus: "succeeded", charged: false and paymentIntentId, with no token. Previously a card saved with a hold could come back as a plain saved card. Capture or void the hold with your secret key, and before you do, read the payment (GET /v1/payment_intents/{id}) and check its metadata.session_id is this session.

1.38.0 — 2026-10-05​

Added​

  • The embedded card form (embed) now places a hold when the session was created with captureMethod: "manual", instead of taking the payment. The buyer's money is authorised, not taken; capture or void it later with POST /v1/payment_intents/{id}/capture or /void. Any other captureMethod takes the payment, as before.
  • collection.submit() reports a hold as chargeStatus: "succeeded" with charged: false and paymentIntentId (the hold to capture). That id comes through the shopper's browser: before you capture, void or fulfil, read the payment with your secret key (GET /v1/payment_intents/{id}) and check its metadata.session_id is this session. If the result of the hold did not arrive in time it reports chargeStatus: "pending" with charged: false: do not charge again; read the session with your secret key (GET /v1/sessions/{id}): paymentStatus: "held" and its paymentIntentId name the hold. A hold is never reported as charged: true.
  • On a hold, collection.submit() never returns a card token, even when the buyer saved their card: the card is saved on our side, and you list it with your secret key (GET /v1/payment_methods?buyer_id=…). (A token's normal next step is a charge, and charging it on top of a hold would bill the buyer twice.) If the buyer asked to save the card and it was not saved, setupForFutureUse is false: the card cannot be charged again. If the checkout reports that the payment was captured rather than held, submit() returns charged: true.
  • One payment per embedded checkout. After the embedded card form places a payment (charged, held, or pending), a second collection.submit() on the same checkout is refused before anything is sent, with frame_session_not_ready and retryable: false: it would be a second payment on the buyer's card. Start a new session for another payment. Sessions created with integrationMode: "elements" are not affected.

Changed​

  • A declined payment's retryable is now always set. It is true only when the checkout re-opened the session for another card (the card form has already been reset — let the buyer submit again). Otherwise it is false: the checkout session is finished, so create a new session for the buyer to pay again. On false the wallet buttons in the same collection are taken down and a resubmit is refused with nothing sent. Previously a decline with no retry instruction left retryable unset and the wallet button up, and a lost response that turned out not to be charged said "ask the buyer to try again" on a session that could not take it.
  • When saving a card is declined and the checkout allows another attempt on the same session, the card form is reset and submit() returns frame_payment_declined with retryable: true; the buyer can enter another card without a new session. Otherwise the decline stays retryable: false.

Fixed​

  • On the embedded card form, collection.submit() no longer waits forever when the form refuses the card (for example, an invalid card number). It now rejects at once with frame_field_validation_failed and nothing is sent. If the form goes silent for any other reason, submit() stops waiting after the 3-D Secure challenge timeout (5 minutes at least) and checks the payment with the server: a payment that went through is reported as a success, a hold as a hold, one still in progress as chargeStatus: "pending", and one that did not complete as frame_3ds_challenge_timeout (nothing was charged; start a new session).
  • The embedded card form now reports the card's real last 4 digits and brand. Previously a card paid without saving could come back as last4: "0000" and brand: "unknown".
  • When the card fields save a card instead of charging it and the issuer refuses the card, submit() now returns frame_payment_declined with retryable: false. It previously returned frame_tokenization_failed saying the response was malformed. Any other unexpected status on a card save returns frame_tokenization_failed naming that status.

1.37.0 — 2026-10-02​

Added​

  • OptionsOptionalElementType, exported as a type: the element types whose options argument collection.create() lets you leave out.

Changed​

  • No Apple Pay / Google Pay buttons for CLF, IQD, ISK, LYD, MGA, UYI and UYW. For these currencies the standards disagree on how many decimal places an amount has, so a wallet sheet could show the buyer a total 10x or 100x off what is charged. The express checkout element draws no buttons and its change event reports frame_wallet_unavailable with a message naming the currency — the same code as "no wallet on this device", so show the card form. Card payments in these currencies are unchanged. If collection.fetchUpdates() moves the total to one of these currencies, the buttons are taken down (closing an open sheet) with the same reason, and a wallet payment that still arrives is refused with nothing sent.
  • setupForFutureUse on a successful tokenize() can now be null. It means you asked to save the card for later and the request was refused, because the session did not identify the buyer (buyerId, buyerEmail or buyer at session create). The payment stands, but the card is saved for this payment only and cannot be charged again. Omitted still means "not asked for". A card charged when the buyer submits reports the same refusal the same way.
  • collection.submit() keeps setupForFutureUse as true / false: a refused save arrives as false (present, never omitted, never true), meaning the card cannot be charged again. To save cards for later, identify the buyer on the session.

Fixed​

  • Apple Pay / Google Pay sheets could show amounts in BHD, JOD, KWD, OMR and TND 10x too large (1.234 KWD appeared as 12.34). They now use three decimal places everywhere the sheet shows money: the total, shipping-option prices and the total after a shipping change. A trailing zero is dropped (1.230 shows as 1.23); the amount is never rounded. If a wallet does not accept a three-decimal amount, its sheet does not open and nothing is charged. What is charged was always correct — only the displayed amount was wrong.
  • collection.create(type) with no options argument no longer crashes with a TypeError. The default placeholder and style apply, exactly as for {}. address still needs { mode: "billing" }; leaving it out now fails with frame_field_validation_failed naming mode.
  • A card saved on the session reported the save you asked for rather than the one that was stored, so a card saved for one payment only could appear reusable. It now reports what was stored.

1.36.0 — 2026-09-28​

Added​

  • collection.fetchUpdates(): after you change the session's amount on your server (a coupon, a shipping choice), call it and wait for it before the buyer pays. It resolves with the new { amount, currency }. The card form and the express checkout button then pay exactly that total, and a payment is refused — nothing charged, frame_wallet_total_mismatch — if the total changes again without another fetchUpdates(). Opt-in; nothing changes until you call it.
  • Apple Pay / Google Pay declines now carry retryable and attemptsRemaining on frame_payment_declined, the same as card declines. Card and wallet attempts share one count. Takes effect once the checkout enables retries for your account.
  • New error frame_sandbox_account_required: a test key was used on a live account, or on a sandbox account with no payment provider. Retrying cannot fix it — use a sandbox account's test keys. Previously this surfaced as frame_session_not_ready.

Changed​

  • An express checkout payment is refused, with nothing charged, if the total changes while the Apple Pay / Google Pay sheet is open or while your onConfirm runs.
  • A collection takes one payment at a time: a wallet payment while a card submit() is in progress (or the reverse) is refused with frame_session_not_ready before anything is sent.
  • Express checkout shipping option id values must be printable ASCII (and at most 64 characters). Other values are refused at mount with frame_field_validation_failed instead of failing after the buyer approves.

Removed​

  • The built-in test simulator, which the checkout retired on 2026-09-24. /v1.36.0/adapters/sandbox.js does not exist (older pinned versions still serve theirs), and /v1/sandbox-iframe.html and /v1/sandbox-iframe.js are no longer served. Nothing in 1.36.0 loads them. Test payments use a sandbox account connected to a payment provider, with that provider's test cards.

No change to how card fields are styled.

1.35.0 — 2026-09-24​

Added​

  • Express checkout (elements.create("express-checkout", …)) can now collect buyer details and handle shipping inside the Apple Pay / Google Pay sheet. All opt-in:
    • collect: the buyer's email, name, phone, billing and/or shipping address.
    • shippingOptions with onShippingAddressChange / onShippingOptionChange: shipping choices and an updated total in the sheet.
    • onConfirm: runs after the buyer approves and before any money moves. Answer { ok: false } (or throw, or take longer than 15 seconds) and nothing is charged.
  • New error codes frame_wallet_total_mismatch and frame_wallet_confirm_failed (nothing charged in either case).
  • Contact fields and shipping options need wallet buttons the SDK draws itself (custom elements-mode sessions); elsewhere they are refused at mount with frame_unsupported_element. onConfirm works everywhere.

Fixed​

  • Card payments routed through Stripe that need a 3-D Secure check now reach the buyer's bank. The SDK had refused Stripe's challenge page, so the payment expired unpaid.
  • A double-tap or a re-tap on a wallet button is reported once, and a re-tap during 3-D Secure reports pending instead of a decline. Dedupe on paymentIntentId on your server as well.
  • A slow wallet charge could close the sheet as failed and then succeed. The sheet now closes without claiming an outcome, and the SDK checks the result with the checkout.

1.34.0 — 2026-09-23​

Added​

  • A declined card can be retried on the same form. frame_payment_declined now carries retryable and attemptsRemaining, and when a retry is allowed the card form resets itself for another card. Takes effect once the checkout enables retries for your account; until then a decline behaves as before.
  • SessionsResource, FieldsResource, ElementsResource, WalletResource and ElementCollectResult are exported as types.

Fixed​

  • If the card form could not be rebuilt after a reset, the decline is reported as retryable: false and asks the buyer to reload.

1.33.1 — 2026-09-16​

Fixed​

  • The error for an unusable 3-D Secure challenge URL now lists every reason the URL can be refused, instead of naming one cause it had not checked.
  • ChallengeAction is exported as a type.

1.33.0 — 2026-09-16​

Added​

  • Browser telemetry records when redirectToChallenge() sends a buyer to their bank, including on live keys, so a 3-D Secure drop-off can be diagnosed.

1.32.0 — 2026-09-16​

Added​

  • vora.redirectToChallenge(): when your server creates a payment intent and it comes back requires_action, pass the challenge URL to this method to send the buyer to their bank. After the bank, the buyer lands on the returnUrl you gave when creating the payment intent (server SDK 2.5.0 or later). An untrusted or unusable URL throws frame_3ds_required and navigates nobody.

1.31.0 — 2026-09-15​

Changed​

  • The card form appears sooner: the SDK opens the connection to the card-field host as soon as it is known, before loading the rest of the form. No change to what is sent or charged.

1.30.0 — 2026-09-12​

Fixed​

  • A charge that is authorized and held (captureMethod: "manual") now reaches submit() as chargeStatus: "succeeded" with charged: false. Before, charged was missing, which could read as paid. Do not fulfil until your server captures.
  • A held Apple Pay / Google Pay payment is reported as a success with a paymentIntentId (use it to capture or void). Before, it was reported as a failure.
  • pending and requires_action results now carry charged: false.