Vora.js changelog
What changed in each release of the Von Payments browser SDK (vora.js).
https://js.vonpay.com/v1/vora.jsupdates 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.mdand 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
FrameErrorcode, with a message you can show the shopper that ends "Nothing was charged." Before, they arrived asframe_tokenization_failedorframe_session_not_ready, both of which read as a failure to retry.retryableisfalseon all of them exceptframe_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 withoutrecurring, 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'srecurring.disclosurenext to the pay button and send the agreement withcollection.submit({ setupForFutureUse: "off_session" })or asave-for-future-usebox 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 newrecurring.disclosurewhen 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 samebuyerIdit 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 withframe_recurring_already_subscribed, and nothing is charged twice.frame_recurring_not_enabled— Subscriptions is not switched on for your account. Sell withoutrecurringand 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 andcollection.submit()), one that saves cards on the hosted payment page only (send the shopper to itscheckoutUrl), or one sent through your own payment gateway with a manual capture (create it withoutcaptureMethod: "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_enabledandframe_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 withnext_action_presentation: "in_page"and areturn_urlon your page's origin, pass its id andclient_read_secrettovora.handleNextAction()(aspaymentIntentandclientReadSecret), 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 throwsframe_payment_declinedwithdeclineCode, as the card form does. When the call ends without an outcome it throws the newframe_next_action_outcome_unknownwith areason(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.reasonis nowThreeDsRequiredReason | NextActionOutcomeUnknownReason; checkcodefirst to narrow it. If the shopper closes the pop-up, or the check runs out of time, it resolvesrequires_actionwith areason: 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 readscancelledorfailed(every other answer: it is paid, or wait for its webhook). Your page's CSP needs the newnext-actionrows ofvora.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: falseto 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
changeevent carrieserror.codeframe_card_brand_not_acceptedwithcomplete: false, andcollection.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. Showerror.messageand let the shopper enter another card on the same checkout;retryable: falsemeans 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 nextsubmit(). The names are checked on everysubmit(), 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 byfetchUpdates()) 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 withintegritynow 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 withbuyerEmail) 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 asframe_tokenization_failedwith status 409. - Every call to the Von Payments checkout API carries an
X-Vora-Versionheader 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 tocheckout.vonpay.com/checkout-staging.vonpay.com, never to anapiBaseUrlof 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.
PulseClientandsubscribeToPaymentIntent()now open the stream withfetch()and send the token in anAuthorization: Bearerheader, 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
pulseStreamTokenfrom the create response aspulseToken. The response's olderpulseTokenfield is alwaysnullin live mode. - The stream token is sent only to the Von Payments checkout (
https://checkout.vonpay.comorhttps://checkout-staging.vonpay.com). For any otherbaseUrl, 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-proxyincluded), passallowCustomBaseUrl: truetonew PulseClient()orsubscribeToPaymentIntent(); the token then goes to your proxy. ForwardPOST /v1/public/payment_intents/{id}/stream_tokenas well as the stream itself. baseUrlmust still resolve to anhttps:address (plainhttp:only forlocalhost,127.0.0.1and[::1]); a relative path is judged by your page's own address. Anything else throws aTypeErrorfromnew PulseClient(), andsubscribeToPaymentIntent()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.comaddress asvora.js, and the stream and its token renewal useconnect-srcfor the API host, as before.
- Pass the payment intent's
- 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, whateverdisplayyour 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. Settelemetry: falseto 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 getcharged: true, a hold (chargeStatus: "succeeded",charged: false,paymentIntentId), or, while the payment is not confirmed yet,chargeStatus: "pending"with nochargedvalue: wait for yourcharge.*webhook and do not charge again. There is notoken, andsetupForFutureUseisfalsewhen 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, answersnot_switched. It resolves with aSessionSwitchResult:{ 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.reasonis 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, answernot_switched. - Until Von Payments switches the step on for checkouts, a call that gets as far as checkout
answers
not_switchedwith reasonnot_available, so your page keeps today's behaviour. Handle everynot_switchedreason 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()andcsp.jsonlist it under thebot-checkfeature.
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 asubmit()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 carriesretryable: falsetoo and keeps its session. Otherframe_provider_request_rejectederrors 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 laterretrieve()with the session id still sends the secret, so a page that retrieves again after an error keeps working. Our error messages now say "callretrieve()again with the same value you passed". - A client secret is sent only to Von Payments (only once your account has client secrets). If
apiBaseUrlpoints 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 checkapiBaseUrland 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
changeevent asframe_binder_load_failed. It now arrives asframe_wallet_unavailablewith areason. Nothing was charged and the wallet buttons stay. If your page hides the wallet buttons onframe_wallet_unavailable, checkreasonfirst: with areason, 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,expMonthandexpYearare there whenever the card's expiry is known. Keep the!== undefinedcheck: 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 aclientSecretwith each session (POST /v1/sessions): pass it tovora.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.idis 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) andframe_client_secret_required(this session needs its client secret). Nothing was charged in either case.
- vora.js sends the client secret only to Von Payments' checkout, on every call for that
session, and never stores it.
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, thechangeevent's error wasframe_binder_load_failed. It is nowframe_wallet_unavailable("this wallet can't be used here — show your card form") witherror.reason. Nothing was charged and the buttons stay.frame_binder_load_failednow means only that the wallet buttons failed to load.- With
reasona 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
reasonit 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_failedshould not do that forframe_wallet_unavailablewith areason: show the card form and leave the buttons, unless the reason is persistent. A page that already treats everyframe_wallet_unavailableas "no wallet here" keeps working, but hides wallets a buyer could have retried. - Types: new
WalletUnavailableReason;ElementChangeEvent.error.reasonis nowThreeDsRequiredReason | WalletUnavailableReason(wasThreeDsRequiredReason). Code that assigns it to aThreeDsRequiredReasonvariable, or switches on it exhaustively, needs to checkerror.codefirst.
- With
Fixed
- When a buyer saves a card, the result of
elements.submit()now includes the card's expiry,expMonth(1-12) andexpYear, 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 throughsubmit(). As before, the two fields are left out (never filled with a made-up date) when the expiry is not known, so keep the!== undefinedcheck. 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/expYearare 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 withprovider_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 amin-heighton 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 aheightor amin-heightis 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, andsubmit({ setupForFutureUse: "off_session" })does it for one payment. Nothing is greyed out. The result says whether the card was actually saved. An unknown value onelements.create()is refused when the collection is created. - Apple Pay / Google Pay carry the buyer's save consent. A ticked
save-for-future-usebox in the same collection asexpress-checkoutnow saves the wallet card too, exactly as for a typed card; a page that runs card and wallet on two sessions passes the box withcreate("express-checkout", { saveForFutureUse: box }). Or use your own wording:create("express-checkout", { setupForFutureUse: "off_session" }). The wallet result reportssetupForFutureUse: truewhen the card was saved,falsewhen 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: trueonsave-for-future-use), for a subscription whose renewals need the saved card. Itschange.completeis the tick.submit()with a new card and the box unticked is refused before anything is sent, with the new error codeframe_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"onexpress-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).confirmfires once, after the check:succeededonly once the payment is confirmed, otherwisepending, with a new optionalpendingReason("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 codeframe_3ds_challenge_cancelled(retryable when the buyer may tap again or pay by card); until the checkout supports that confirmation, Cancel ends aspendingwithpendingReason: "challenge_closed". The element falls back to the full-page check when your Content-Security-Policy refuses the modal (new CSP featurewallet-modalincsp.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'ssecurityCheckobject tocollection.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_taborexpired— never a result: ask your server, which asks the checkout.{ signal }andunmount()close it. An object with no usable link is refused withframe_3ds_requiredand no pop-up. It downloads only when called. New CSP featurebank-checkincsp.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: truewithattemptsRemainingand 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:
clickandcloseevents.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 eachclick, when that attempt is over, and says how:outcomeis"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 typesExpressCheckoutClickEvent,ExpressCheckoutCloseEventandExpressCheckoutAttemptOutcome.
Changed
- Express checkout: the card form is locked from the wallet approval. A card
submit()on the same collection is refused withframe_session_not_ready, nothing sent, from the moment the buyer approves the wallet sheet (before youronConfirmruns) 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 itstokenize()step separately. It comes from the same CDN, at the same version asvora.js, when you callvora.fields.create(), sovora.jsitself 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 }withframe_binder_load_failedand nothing is sent. Results and error codes are otherwise unchanged;vora.elementsis 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 isframe_other_payment_in_progressinstead offrame_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, orpendingwhile it runs). Anywhere else, for example a card save, it is the new error codeframe_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 ownchangehandler. Calling the collection'ssubmit()from the express-checkout element'schangehandler (oncomplete: 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_readyerror ("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 withCache-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. WithloadVora.setLoadParameters({ pin: true }), awindow.Voraalready on the page is used only when every vora.js<script>tag on the page is the pinned URL with the sameintegrityhash. Awindow.Voraleft by the auto-updating/v1/vora.jstag, or one with no vora.js tag behind it, now rejects withversion_mismatcheven when its version matches, instead of being used without the integrity check. Unpinned loads are unchanged.js.vonpay.comresponses carryX-Content-Type-Options: nosniff, andhttps://js.vonpay.com/v1/vora.jsis servedCache-Control: private, max-age=300withVary: 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_failederror, 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 coverssetupForFutureUse,allowRedisplay,displayScopeandsavedCardDisplayScope(camelCase or snake_case). In 1.42.0, passing one of them madesubmit()returnframe_field_validation_failedwithout 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 settelemetry: 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.
- A built-in default look on every page, even one that passes no
styleortheme. 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 combinedcardelement 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,@layerrules (Tailwind v4 classes included),styleandthemeall 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,styleandthemestill override it; only your layered CSS does not.
- Content-Security-Policy, optional: vora.js adds one line,
styleandthemenow also style the elements drawn into your page (email,cardholder,address,payment-method-picker,saved-methodsandsave-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 tosave-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
cardelement 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 layervora-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 asp-0orborder-0),styleandthemeall 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, elsestyle-src, elsedefault-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 yourreport-uritoo, if set), the look still applies, and your plain CSS andstyle/themestill override it. It is listed underifNoUnsafeInlineincsp.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.
- Your CSS always wins, in a cascade layer or not: every default has zero specificity
(
styleandthemenow apply to the elements drawn into your page —email,cardholder,address,payment-method-picker,saved-methodsandsave-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, socolor.labeldoes not apply there.- If you pass neither
stylenortheme, nothing is written inline: these elements get only the built-in default look above, which any CSS of yours overrides. - ⚠️ A collection
themestyles 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 atcreate(), as on the card fields.
- If you pass neither
- With a wallet button and a card form in the same
vora.elementscollection, once a wallet payment succeeds (charged, or authorised and held on manual capture) a later cardsubmit()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 fromsubmit(). - A payment on a checkout now locks every
vora.elementscollection on that checkout session, not only the one it was made in: a secondvora.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 firstsubmit()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 oldervora.fieldscard API is not covered (it only saves a card) and that a page script that edits the objectvora.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. Passingsubmit({ setupForFutureUse })(orallowRedisplay,displayScope,savedCardDisplayScope, in camelCase or snake_case) now returnsframe_field_validation_failedand 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. Withvora.elements, the buyer's consent comes only from thesave-for-future-useelement: mount it, and its tick is sent with the card. Any other optionsubmit()does not read now logs one console warning naming it, and the submit goes ahead.- TypeScript types:
collection.submit()now returnsSubmitResultas three shapes. WhenchargeStatusis"requires_action",redirectUrlis always a string, so the 3-D Secure redirect compiles understrictwithout a!or a cast:This changes types only; the SDK behaves exactly as before. The shapes are exported asconst result = await collection.submit();if (result.chargeStatus === "requires_action") {window.location.href = result.redirectUrl; // nothing has been charged yet}SubmitResultRequiresAction,SubmitResultNoActionandSubmitResultCollected({ status: "card_collected" }and nothing else), with the shared fields onSubmitResultFields. Reading any field compiles as before. If your code declaresinterface X extends SubmitResult, extendSubmitResultFieldsinstead; a test fixture typedSubmitResultwithchargeStatus: "requires_action"now needs aredirectUrl. - 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 onlystatus, 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: itschangeevent carrieschecked: trueorfalse. 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-fieldandvora-field--security-codewhen it mounts,vora-field--focuswhile the buyer is in the field,vora-field--invalidonce they leave a code that is not valid, andvora-field--completewhen the code is valid. They are removed onunmount(). Styling only: callsubmit()to check the code.vora.securityCode(): on test keys, the firstsubmit()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 withsecurityCodeVerification: "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 asdeclineCodein 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 stillframe_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.elementscollection, 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 (withhandleRedirect: false) was still in a later card result, aschargeStatus: "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 itsclassandid), so a reference you kept to it pointed at an element no longer on the page, and afterunmount()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
onConfirmwas 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 firstmount()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 includespaymentIntentId, as the other wallet outcomes already did. Use it to match the payment to your order, for example withhandleRedirect: falseon 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 thecharge.*webhook, then read the payment with your secret key and check its status andmetadata.session_idbefore you capture, void or fulfil. - Card form (
vora.elementswithcard, orcard-number/card-expiry/card-cvc): when the bank asks the buyer to authenticate (chargeStatus: "requires_action"),submit()now includespaymentIntentIdtoo, 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 thecharge.*webhook, then read the payment with your secret key and check its status andmetadata.session_idbefore 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 tonew Vora()afterwards no longer has any effect. No change to the API; you can still add your own properties to theVoraobject 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 aftersubmit()resolves. A charge with a security code session that was not confirmed this way is refused with422 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 withframe_tokenization_failedand the buyer can submit again. A session that is already used or expired rejects withframe_session_expired(open a new one on your server), an unknown one withframe_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:changereportscomplete: falseandcollection.submit()returnsframe_field_validation_failedwithout 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 emitserror) the new codeframe_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 Policyframe-srcthat 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 combinedcard) 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 withvora-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
changeevent now reportscomplete: trueonly once the card details are valid, andcomplete: falseagain if they become invalid. Until now it reportedcomplete: trueas soon as the form loaded, even for an empty card or a mistyped number. Thevora-field--completeclass follows the same rule. If you enable your Pay button oncomplete, 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 withframe_field_validation_failedand 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_failedat once, instead offrame_tokenization_failedafter 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 bymount()(the security-code field emits it aserror) 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 combinedcard) now getvora-field--focuswhile the buyer is in the field, andvora-field--invalidonce the buyer leaves a field whose value is not valid (until it is fixed). Until now onlyvora-field--completewas set on them. The combinedcardgets--focuswhile any of its three fields has focus. A field left empty after the buyer was in it also counts as not valid. Theirfocus,blurandchangeevents 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 throwsframe_binder_load_failedand your element is left as it was: what was added to it is removed and thevora-fieldclasses come off. Until now the element kept an empty card box andmount()threw the provider's own error. Nothing is charged. The form is released: the other elements of thatvora.elements.create()form are taken down too, and creating a new card form before you retrieve the session again throwsframe_session_not_ready. Callvora.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_expiredat 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 withintegrationMode: "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
cardelement 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 combinedcardagain showed six boxes; vora-field--completewas set on an element that was no longer in the page;- with
showIcon: truethe card-number box got an inlinedisplay: inline-flexand stopped filling its row. Your element now stays in place with no inline style, and the brand icon stays inside it.
- 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
- Creating a new form from the same
Voraaftercollection.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"), …) withframe_session_not_ready, and the message tells you what to do: callvora.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 example44px), not only amin-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.comfor 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 answer200, keep sending your last list.
Known limitation
- On the card fields of an
integrationMode: "elements"session, vora.js setsvora-field, the type class andvora-field--complete(on all the card fields at once, when the whole card is complete). It does not setvora-field--focusorvora-field--invalidon them. Show a card error from the result ofcollection.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, oncesubmit()resolves, charges withsecurity_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, andVora.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 theexpress-checkoutelement no longer load it. Theexpress-checkoutelement 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 asincorrect_card_details, anderror.messagereads "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 ascard_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 asframe_payment_declinedwith "The payment was declined.", with no code.) The exact reason still reaches your server on thecharge.failedwebhook (decline_code).retryableand the rest of the decline are unchanged.
Deprecated
avsResultCodeandcvvResultCodeon thesubmit()result, and theAvsResultCode/CvvResultCodetypes. The address and security-code match results are no longer returned to the browser, for the same reason, so these fields are always absent. Readavs_result_codeandcvv_result_codeon your server from thecharge.succeeded/charge.failedwebhook. The fields stay in the types, so existing code keeps compiling.
Fixed
- Embedded card form (
embedsessions): 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 returnsframe_payment_declined(it wasframe_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.attemptsRemainingsays how many tries are left when known.retryable: false: the session has ended. Start a new session for the buyer to pay again. A furthercollection.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 throwsframe_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 theexpress-checkoutelement. - 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_readyanswercollection.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,expMonthandexpYearon payment results will benullwhen the card is not known, instead of the placeholders"0000"and"unknown"used today. If you show these fields, be ready fornullthen. 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()returnedframe_payment_declinedwithretryable: 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 withcaptureMethod: "manual") the waycollection.submit()does:chargeStatus: "succeeded",charged: falseandpaymentIntentId, 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 itsmetadata.session_idis this session.
1.38.0 — 2026-10-05
Added
- The embedded card form (
embed) now places a hold when the session was created withcaptureMethod: "manual", instead of taking the payment. The buyer's money is authorised, not taken; capture or void it later withPOST /v1/payment_intents/{id}/captureor/void. Any othercaptureMethodtakes the payment, as before. collection.submit()reports a hold aschargeStatus: "succeeded"withcharged: falseandpaymentIntentId(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 itsmetadata.session_idis this session. If the result of the hold did not arrive in time it reportschargeStatus: "pending"withcharged: false: do not charge again; read the session with your secret key (GET /v1/sessions/{id}):paymentStatus: "held"and itspaymentIntentIdname the hold. A hold is never reported ascharged: 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,setupForFutureUseisfalse: the card cannot be charged again. If the checkout reports that the payment was captured rather than held,submit()returnscharged: 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, withframe_session_not_readyandretryable: false: it would be a second payment on the buyer's card. Start a new session for another payment. Sessions created withintegrationMode: "elements"are not affected.
Changed
- A declined payment's
retryableis now always set. It istrueonly when the checkout re-opened the session for another card (the card form has already been reset — let the buyer submit again). Otherwise it isfalse: the checkout session is finished, so create a new session for the buyer to pay again. Onfalsethe wallet buttons in the same collection are taken down and a resubmit is refused with nothing sent. Previously a decline with no retry instruction leftretryableunset 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()returnsframe_payment_declinedwithretryable: true; the buyer can enter another card without a new session. Otherwise the decline staysretryable: 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 withframe_field_validation_failedand 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 aschargeStatus: "pending", and one that did not complete asframe_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"andbrand: "unknown". - When the card fields save a card instead of charging it and the issuer refuses the card,
submit()now returnsframe_payment_declinedwithretryable: false. It previously returnedframe_tokenization_failedsaying the response was malformed. Any other unexpected status on a card save returnsframe_tokenization_failednaming that status.
1.37.0 — 2026-10-02
Added
OptionsOptionalElementType, exported as a type: the element types whose options argumentcollection.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
changeevent reportsframe_wallet_unavailablewith 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. Ifcollection.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. setupForFutureUseon a successfultokenize()can now benull. It means you asked to save the card for later and the request was refused, because the session did not identify the buyer (buyerId,buyerEmailorbuyerat 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()keepssetupForFutureUseastrue/false: a refused save arrives asfalse(present, never omitted, nevertrue), 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 aTypeError. The default placeholder and style apply, exactly as for{}.addressstill needs{ mode: "billing" }; leaving it out now fails withframe_field_validation_failednamingmode.- 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 anotherfetchUpdates(). Opt-in; nothing changes until you call it.- Apple Pay / Google Pay declines now carry
retryableandattemptsRemainingonframe_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 asframe_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
onConfirmruns. - A collection takes one payment at a time: a wallet payment while a card
submit()is in progress (or the reverse) is refused withframe_session_not_readybefore anything is sent. - Express checkout shipping option
idvalues must be printable ASCII (and at most 64 characters). Other values are refused at mount withframe_field_validation_failedinstead 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.jsdoes not exist (older pinned versions still serve theirs), and/v1/sandbox-iframe.htmland/v1/sandbox-iframe.jsare 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.shippingOptionswithonShippingAddressChange/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_mismatchandframe_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.onConfirmworks 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
pendinginstead of a decline. Dedupe onpaymentIntentIdon 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_declinednow carriesretryableandattemptsRemaining, 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,WalletResourceandElementCollectResultare exported as types.
Fixed
- If the card form could not be rebuilt after a reset, the decline is reported as
retryable: falseand 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.
ChallengeActionis 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 backrequires_action, pass the challenge URL to this method to send the buyer to their bank. After the bank, the buyer lands on thereturnUrlyou gave when creating the payment intent (server SDK 2.5.0 or later). An untrusted or unusable URL throwsframe_3ds_requiredand 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 reachessubmit()aschargeStatus: "succeeded"withcharged: false. Before,chargedwas 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. pendingandrequires_actionresults now carrycharged: false.