--- title: "Wallets" description: "10 operations, with parameters and examples." url: https://docs.fluveo.com/api/wallets/ --- > Index of every page: https://docs.fluveo.com/llms.txt. Integrating Fluveo? Read https://docs.fluveo.com/agents/integrate.md first. > Too long? This page with code in one language only: https://docs.fluveo.com/api/wallets.curl.md (cURL), https://docs.fluveo.com/api/wallets.node.md (Node.js), https://docs.fluveo.com/api/wallets.python.md (Python), https://docs.fluveo.com/api/wallets.php.md (PHP). # Wallets 10 operations, with parameters and examples. A store turns Apple Pay and Google Pay on and off for its checkout, and names the websites where they may appear. The store's payment method configuration holds one switch per wallet; cards are always on and shown read only, and no other method is listed. A payment method domain registers one website, and validate asks again whether each wallet may show there. A wallet button appears only when the store has that wallet on and the page's domain is registered and active for it. A store that is rejected, suspended or closed is refused, and live mode needs an approved store. A wallet the store cannot offer stays off: turning it on is refused. A domain shows the registration status and any status details for each of its six wallets. A domain's registration status does not enable a wallet; the store's payment method configuration controls whether it may offer that wallet. An Apple Pay payment enters through POST /v1/tokens: send the Apple Pay payment data the device returned, then create a PaymentMethod from the token with card[token], or pay with it directly in payment_method_data[card][token]. A token is used once, and the card it makes shows its wallet in card.wallet. Apple Pay checks each domain with a domain association file: download it from the wallet domains in the Dashboard's settings and host it at https:///.well-known/apple-developer-merchantid-domain-association before you validate the domain. Every domain of a store hosts the same file. Send every request to `https://api.fluveo.com/v1` with your secret key as a Bearer token. This page lists only what Fluveo serves; [the OpenAPI file](https://docs.fluveo.com/openapi.json) holds the same operations. An operation or a parameter marked **Preview** works, but it is not locked yet and may change: [what Preview means](https://docs.fluveo.com/api.md#preview). > **For AI agents:** > > Use plain HTTP; install no payments SDK. Send `Authorization: Bearer sk_test_...` and a fresh `Idempotency-Key` on every POST; reuse the same key only when you retry that same POST. Send only the documented parameters. An operation or a parameter marked Preview may change: prefer the ones without the mark. ## Lists the store's payment method configuration: the one its checkout uses (Preview) `GET /v1/payment_method_configurations` Permission: [`rak_payment_method_configurations_read`](https://docs.fluveo.com/permissions.md#payment_method_configurations). **Preview:** this operation works, but it is not locked yet; it may change. **Query parameters** - `active` (boolean, optional): Only configurations that are active (true) or not (false). - `application` (string, optional): Only configurations made by this application. The store's own configuration names none, so any value lists nothing. - `ending_before` (string, optional): Cursor: the id of the first object of the current page, to get the previous page. Do not send it with starting_after. - `limit` (integer, optional): How many objects to return, from 1 to 100. Default 10. - `starting_after` (string, optional): Cursor: the id of the last object of the previous page, to get the next page. Do not send it with ending_before. **Headers** - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. Returns a list of [`payment_method_configuration`](https://docs.fluveo.com/api/wallets.md#object-payment_method_configuration) objects. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_configurations \ -H "Authorization: Bearer sk_test_..." ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_configurations", { method: "GET", headers: { "Authorization": "Bearer sk_test_...", }, }); console.log(await response.json()); ``` Python: ```python import requests response = requests.get( "https://api.fluveo.com/v1/payment_method_configurations", headers={"Authorization": "Bearer sk_test_..."}, ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "GET", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", ], ]); echo curl_exec($ch); ``` ## Creates a payment method domain (Preview) `POST /v1/payment_method_domains` Permission: [`rak_payment_method_domain_write`](https://docs.fluveo.com/permissions.md#payment_method_domain). **Preview:** this operation works, but it is not locked yet; it may change. **Headers** - `Idempotency-Key` (string, optional): Send a unique key, 1 to 255 characters, on every POST. A retry with the same key and the same body returns the first answer instead of acting twice (with Idempotent-Replayed: true); the same key with another body is refused. Keys are kept 7 days, except on POST /v1/checkout/sessions, POST /v1/checkout/sessions/{session} and POST /v1/webhook_endpoints, where a key holds 24 hours; webhook endpoint keys are also capped at the newest 32 per store and mode. Do not rely on a replay after that window. GET and DELETE ignore it. - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. **Body parameters** - `domain_name` (string, required): The website where the store's checkout runs, as a bare host name such as shop.example.com: no scheme, port or path. - `enabled` (boolean, optional): Whether wallets may show on this domain. Default true. Use only the documented body parameters. Send a new `Idempotency-Key` with each new request, and the same key again only to retry that request. Returns a [`payment_method_domain`](https://docs.fluveo.com/api/wallets.md#object-payment_method_domain) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_domains \ -H "Authorization: Bearer sk_test_..." \ -H "Idempotency-Key: $(uuidgen)" \ --data-urlencode "domain_name=shop.example.com" ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_domains", { method: "POST", headers: { "Authorization": "Bearer sk_test_...", "Idempotency-Key": crypto.randomUUID(), }, body: new URLSearchParams([["domain_name","shop.example.com"]]), }); console.log(await response.json()); ``` Python: ```python import uuid import requests response = requests.post( "https://api.fluveo.com/v1/payment_method_domains", headers={"Authorization": "Bearer sk_test_...", "Idempotency-Key": str(uuid.uuid4())}, data=[("domain_name", "shop.example.com")], ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", "Idempotency-Key: " . bin2hex(random_bytes(16)), ], CURLOPT_POSTFIELDS => "domain_name=shop.example.com", ]); echo curl_exec($ch); ``` ## Lists payment method domain objects, newest first (Preview) `GET /v1/payment_method_domains` Permission: [`rak_payment_method_domain_read`](https://docs.fluveo.com/permissions.md#payment_method_domain). **Preview:** this operation works, but it is not locked yet; it may change. **Query parameters** - `domain_name` (string, optional): Only the domain with this name. - `enabled` (boolean, optional): Only domains that are on (true) or off (false). - `ending_before` (string, optional): Cursor: the id of the first object of the current page, to get the previous page. Do not send it with starting_after. - `limit` (integer, optional): How many objects to return, from 1 to 100. Default 10. - `starting_after` (string, optional): Cursor: the id of the last object of the previous page, to get the next page. Do not send it with ending_before. **Headers** - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. Returns a list of [`payment_method_domain`](https://docs.fluveo.com/api/wallets.md#object-payment_method_domain) objects. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_domains \ -H "Authorization: Bearer sk_test_..." ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_domains", { method: "GET", headers: { "Authorization": "Bearer sk_test_...", }, }); console.log(await response.json()); ``` Python: ```python import requests response = requests.get( "https://api.fluveo.com/v1/payment_method_domains", headers={"Authorization": "Bearer sk_test_..."}, ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "GET", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", ], ]); echo curl_exec($ch); ``` ## Creates a token (Preview) `POST /v1/tokens` Permission: none. [No restricted key](https://docs.fluveo.com/permissions.md#no-restricted-key) may call this operation; only a secret key may. **Preview:** this operation works, but it is not locked yet; it may change. **Headers** - `Idempotency-Key` (string, optional): Send a unique key, 1 to 255 characters, on every POST. A retry with the same key and the same body returns the first answer instead of acting twice (with Idempotent-Replayed: true); the same key with another body is refused. Keys are kept 7 days, except on POST /v1/checkout/sessions, POST /v1/checkout/sessions/{session} and POST /v1/webhook_endpoints, where a key holds 24 hours; webhook endpoint keys are also capped at the newest 32 per store and mode. Do not rely on a replay after that window. GET and DELETE ignore it. - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. **Body parameters** - `pk_token` (string, required): The Apple Pay payment data the device returned (PKPayment's token.paymentData), as JSON. It makes a single-use card token and is never stored. In test mode, a pk_token_transaction_id of ApplePayStubs~~~~ makes a token of that test card whatever pk_token holds; live mode refuses it. - `pk_token_instrument_name` (string, optional): The card's name as Apple Pay shows it (PKPaymentMethod displayName). Optional. - `pk_token_payment_network` (string, optional): The card network as Apple Pay names it (PKPaymentMethod network), such as Visa or MasterCard. Optional. - `pk_token_transaction_id` (string, optional): Apple Pay's transaction identifier (PKPaymentToken transactionIdentifier). Optional; see pk_token for its test mode use. Use only the documented body parameters. Send a new `Idempotency-Key` with each new request, and the same key again only to retry that request. Returns a [`token`](https://docs.fluveo.com/api/wallets.md#object-token) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/tokens \ -H "Authorization: Bearer sk_test_..." \ -H "Idempotency-Key: $(uuidgen)" \ --data-urlencode "pk_token={\"version\":\"EC_v1\",\"data\":\"...\",\"signature\":\"...\",\"header\":{}}" \ --data-urlencode "pk_token_instrument_name=Visa 4242" \ --data-urlencode "pk_token_payment_network=Visa" \ --data-urlencode "pk_token_transaction_id=..." ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/tokens", { method: "POST", headers: { "Authorization": "Bearer sk_test_...", "Idempotency-Key": crypto.randomUUID(), }, body: new URLSearchParams([["pk_token","{\"version\":\"EC_v1\",\"data\":\"...\",\"signature\":\"...\",\"header\":{}}"],["pk_token_instrument_name","Visa 4242"],["pk_token_payment_network","Visa"],["pk_token_transaction_id","..."]]), }); console.log(await response.json()); ``` Python: ```python import uuid import requests response = requests.post( "https://api.fluveo.com/v1/tokens", headers={"Authorization": "Bearer sk_test_...", "Idempotency-Key": str(uuid.uuid4())}, data=[("pk_token", "{\"version\":\"EC_v1\",\"data\":\"...\",\"signature\":\"...\",\"header\":{}}"), ("pk_token_instrument_name", "Visa 4242"), ("pk_token_payment_network", "Visa"), ("pk_token_transaction_id", "...")], ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", "Idempotency-Key: " . bin2hex(random_bytes(16)), ], CURLOPT_POSTFIELDS => "pk_token=%7B%22version%22%3A%22EC_v1%22%2C%22data%22%3A%22...%22%2C%22signature%22%3A%22...%22%2C%22header%22%3A%7B%7D%7D&pk_token_instrument_name=Visa%204242&pk_token_payment_network=Visa&pk_token_transaction_id=...", ]); echo curl_exec($ch); ``` ## Updates a payment method configuration `POST /v1/payment_method_configurations/{configuration}` Permission: [`rak_payment_method_configurations_write`](https://docs.fluveo.com/permissions.md#payment_method_configurations). **Path parameters** - `configuration` (string, required): The id of the payment method configuration. **Headers** - `Idempotency-Key` (string, optional): Send a unique key, 1 to 255 characters, on every POST. A retry with the same key and the same body returns the first answer instead of acting twice (with Idempotent-Replayed: true); the same key with another body is refused. Keys are kept 7 days, except on POST /v1/checkout/sessions, POST /v1/checkout/sessions/{session} and POST /v1/webhook_endpoints, where a key holds 24 hours; webhook endpoint keys are also capped at the newest 32 per store and mode. Do not rely on a replay after that window. GET and DELETE ignore it. - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. **Body parameters** - `apple_pay` (object, optional): Apple Pay for this store: display_preference[preference] on or off. Card stays on while either wallet is on. - `display_preference` (object, optional) - `preference` (enum, optional): One of: `none`, `off`, `on`. - `boleto` (object, optional, preview): Boleto: display_preference[preference] on. Boleto stays on, and a store that does not take Boleto cannot turn it on. - `display_preference` (object, optional) - `preference` (enum, optional): One of: `none`, `off`, `on`. - `card` (object, optional, preview): Cards for this store: display_preference[preference] on, off or none. Card stays on while either wallet is on, and on a store that offers no wallet. - `display_preference` (object, optional) - `preference` (enum, optional): One of: `none`, `off`, `on`. - `google_pay` (object, optional): Google Pay for this store: display_preference[preference] on or off. Card stays on while either wallet is on. - `display_preference` (object, optional) - `preference` (enum, optional): One of: `none`, `off`, `on`. - `pix` (object, optional, preview): Pix: display_preference[preference] on. Pix stays on, and a store that does not take Pix cannot turn it on. - `display_preference` (object, optional) - `preference` (enum, optional): One of: `none`, `off`, `on`. Use only the documented body parameters. Send a new `Idempotency-Key` with each new request, and the same key again only to retry that request. Returns a [`payment_method_configuration`](https://docs.fluveo.com/api/wallets.md#object-payment_method_configuration) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_configurations/configuration_123 \ -H "Authorization: Bearer sk_test_..." \ -H "Idempotency-Key: $(uuidgen)" \ --data-urlencode "apple_pay[display_preference][preference]=on" ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_configurations/configuration_123", { method: "POST", headers: { "Authorization": "Bearer sk_test_...", "Idempotency-Key": crypto.randomUUID(), }, body: new URLSearchParams([["apple_pay[display_preference][preference]","on"]]), }); console.log(await response.json()); ``` Python: ```python import uuid import requests response = requests.post( "https://api.fluveo.com/v1/payment_method_configurations/configuration_123", headers={"Authorization": "Bearer sk_test_...", "Idempotency-Key": str(uuid.uuid4())}, data=[("apple_pay[display_preference][preference]", "on")], ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", "Idempotency-Key: " . bin2hex(random_bytes(16)), ], CURLOPT_POSTFIELDS => "apple_pay%5Bdisplay_preference%5D%5Bpreference%5D=on", ]); echo curl_exec($ch); ``` ## Retrieves a payment method configuration (Preview) `GET /v1/payment_method_configurations/{configuration}` Permission: [`rak_payment_method_configurations_read`](https://docs.fluveo.com/permissions.md#payment_method_configurations). **Preview:** this operation works, but it is not locked yet; it may change. **Path parameters** - `configuration` (string, required): The id of the payment method configuration. **Headers** - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. Returns a [`payment_method_configuration`](https://docs.fluveo.com/api/wallets.md#object-payment_method_configuration) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_configurations/configuration_123 \ -H "Authorization: Bearer sk_test_..." ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_configurations/configuration_123", { method: "GET", headers: { "Authorization": "Bearer sk_test_...", }, }); console.log(await response.json()); ``` Python: ```python import requests response = requests.get( "https://api.fluveo.com/v1/payment_method_configurations/configuration_123", headers={"Authorization": "Bearer sk_test_..."}, ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "GET", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", ], ]); echo curl_exec($ch); ``` ## Turns a domain on or off for Apple Pay and Google Pay, and returns the domain (Preview) `POST /v1/payment_method_domains/{payment_method_domain}` Permission: [`rak_payment_method_domain_write`](https://docs.fluveo.com/permissions.md#payment_method_domain). **Preview:** this operation works, but it is not locked yet; it may change. **Path parameters** - `payment_method_domain` (string, required): The id of the payment method domain. **Headers** - `Idempotency-Key` (string, optional): Send a unique key, 1 to 255 characters, on every POST. A retry with the same key and the same body returns the first answer instead of acting twice (with Idempotent-Replayed: true); the same key with another body is refused. Keys are kept 7 days, except on POST /v1/checkout/sessions, POST /v1/checkout/sessions/{session} and POST /v1/webhook_endpoints, where a key holds 24 hours; webhook endpoint keys are also capped at the newest 32 per store and mode. Do not rely on a replay after that window. GET and DELETE ignore it. - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. **Body parameters** - `enabled` (boolean, optional): Whether wallets may show on this domain: false turns the domain off, true turns it on again. Use only the documented body parameters. Send a new `Idempotency-Key` with each new request, and the same key again only to retry that request. Returns a [`payment_method_domain`](https://docs.fluveo.com/api/wallets.md#object-payment_method_domain) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123 \ -H "Authorization: Bearer sk_test_..." \ -H "Idempotency-Key: $(uuidgen)" \ --data-urlencode "enabled=false" ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123", { method: "POST", headers: { "Authorization": "Bearer sk_test_...", "Idempotency-Key": crypto.randomUUID(), }, body: new URLSearchParams([["enabled","false"]]), }); console.log(await response.json()); ``` Python: ```python import uuid import requests response = requests.post( "https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123", headers={"Authorization": "Bearer sk_test_...", "Idempotency-Key": str(uuid.uuid4())}, data=[("enabled", "false")], ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", "Idempotency-Key: " . bin2hex(random_bytes(16)), ], CURLOPT_POSTFIELDS => "enabled=false", ]); echo curl_exec($ch); ``` ## Retrieves a payment method domain (Preview) `GET /v1/payment_method_domains/{payment_method_domain}` Permission: [`rak_payment_method_domain_read`](https://docs.fluveo.com/permissions.md#payment_method_domain). **Preview:** this operation works, but it is not locked yet; it may change. **Path parameters** - `payment_method_domain` (string, required): The id of the payment method domain. **Headers** - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. Returns a [`payment_method_domain`](https://docs.fluveo.com/api/wallets.md#object-payment_method_domain) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123 \ -H "Authorization: Bearer sk_test_..." ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123", { method: "GET", headers: { "Authorization": "Bearer sk_test_...", }, }); console.log(await response.json()); ``` Python: ```python import requests response = requests.get( "https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123", headers={"Authorization": "Bearer sk_test_..."}, ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "GET", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", ], ]); echo curl_exec($ch); ``` ## Retrieves a token (Preview) `GET /v1/tokens/{token}` Permission: none. [No restricted key](https://docs.fluveo.com/permissions.md#no-restricted-key) may call this operation; only a secret key may. **Preview:** this operation works, but it is not locked yet; it may change. **Path parameters** - `token` (string, required): The id of the token. **Headers** - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. Returns a [`token`](https://docs.fluveo.com/api/wallets.md#object-token) object. **Request** cURL: ```bash curl https://api.fluveo.com/v1/tokens/tok_123 \ -H "Authorization: Bearer sk_test_..." ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/tokens/tok_123", { method: "GET", headers: { "Authorization": "Bearer sk_test_...", }, }); console.log(await response.json()); ``` Python: ```python import requests response = requests.get( "https://api.fluveo.com/v1/tokens/tok_123", headers={"Authorization": "Bearer sk_test_..."}, ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "GET", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", ], ]); echo curl_exec($ch); ``` ## Asks again whether Apple Pay and Google Pay may show on this domain, and returns the domain with each wallet's status (Preview) `POST /v1/payment_method_domains/{payment_method_domain}/validate` Permission: [`rak_payment_method_domain_write`](https://docs.fluveo.com/permissions.md#payment_method_domain). **Preview:** this operation works, but it is not locked yet; it may change. **Path parameters** - `payment_method_domain` (string, required): The id of the payment method domain. **Headers** - `Idempotency-Key` (string, optional): Send a unique key, 1 to 255 characters, on every POST. A retry with the same key and the same body returns the first answer instead of acting twice (with Idempotent-Replayed: true); the same key with another body is refused. Keys are kept 7 days, except on POST /v1/checkout/sessions, POST /v1/checkout/sessions/{session} and POST /v1/webhook_endpoints, where a key holds 24 hours; webhook endpoint keys are also capped at the newest 32 per store and mode. Do not rely on a replay after that window. GET and DELETE ignore it. - `Fluveo-Version` (enum, optional): Optional. The only version Fluveo serves is 2026-05-27.dahlia; any other value is refused with a 400. Every answer names that version in its own Fluveo-Version header, except the refusals Fluveo gives before it reads the request (no key, an unknown key, an unknown URL, a body that is not a form) and a file's bytes, which name no version and no Request-Id. One of: `2026-05-27.dahlia`. Use only the documented body parameters. Send a new `Idempotency-Key` with each new request, and the same key again only to retry that request. Returns a [`payment_method_domain`](https://docs.fluveo.com/api/wallets.md#object-payment_method_domain) object. **Request** cURL: ```bash curl -X POST https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123/validate \ -H "Authorization: Bearer sk_test_..." \ -H "Idempotency-Key: $(uuidgen)" ``` Node.js: ```javascript const response = await fetch("https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123/validate", { method: "POST", headers: { "Authorization": "Bearer sk_test_...", "Idempotency-Key": crypto.randomUUID(), }, }); console.log(await response.json()); ``` Python: ```python import uuid import requests response = requests.post( "https://api.fluveo.com/v1/payment_method_domains/payment_method_domain_123/validate", headers={"Authorization": "Bearer sk_test_...", "Idempotency-Key": str(uuid.uuid4())}, ) print(response.json()) ``` PHP: ```php true, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_HTTPHEADER => [ "Authorization: Bearer sk_test_...", "Idempotency-Key: " . bin2hex(random_bytes(16)), ], CURLOPT_POSTFIELDS => "", ]); echo curl_exec($ch); ``` ## The payment_method_configuration object **Attributes** - `acss_debit` (object) - `active` (boolean) - `affirm` (object) - `afterpay_clearpay` (object) - `alipay` (object) - `alma` (object) - `amazon_pay` (object) - `apple_pay` (object) - `application` (string, nullable) - `au_becs_debit` (object) - `bacs_debit` (object) - `bancontact` (object) - `billie` (object) - `bizum` (object) - `blik` (object) - `boleto` (object) - `card` (object) - `cartes_bancaires` (object) - `cashapp` (object) - `crypto` (object) - `customer_balance` (object) - `eps` (object) - `fpx` (object) - `giropay` (object) - `google_pay` (object) - `grabpay` (object) - `id` (string) - `ideal` (object) - `is_default` (boolean) - `jcb` (object) - `kakao_pay` (object) - `klarna` (object) - `konbini` (object) - `kr_card` (object) - `link` (object) - `livemode` (boolean) - `mb_way` (object) - `mobilepay` (object) - `multibanco` (object) - `name` (string) - `naver_pay` (object) - `nz_bank_account` (object) - `object` (enum): One of: `payment_method_configuration`. - `oxxo` (object) - `p24` (object) - `parent` (string, nullable) - `pay_by_bank` (object) - `payco` (object) - `paynow` (object) - `paypal` (object) - `payto` (object) - `pix` (object) - `promptpay` (object) - `revolut_pay` (object) - `samsung_pay` (object) - `satispay` (object) - `scalapay` (object) - `sepa_debit` (object) - `sofort` (object) - `sunbit` (object) - `swish` (object) - `twint` (object) - `upi` (object) - `us_bank_account` (object) - `wechat_pay` (object) - `zip` (object) ## The payment_method_domain object **Attributes** - `amazon_pay` (object) - `apple_pay` (object) - `created` (integer) - `domain_name` (string) - `enabled` (boolean) - `google_pay` (object) - `id` (string) - `klarna` (object) - `link` (object) - `livemode` (boolean) - `object` (enum): One of: `payment_method_domain`. - `paypal` (object) ## The token object Ids start with `tok_`. **Attributes** - `bank_account` (object) - `card` (object) - `client_ip` (string, nullable) - `created` (integer) - `id` (string) - `livemode` (boolean) - `object` (enum): One of: `token`. - `type` (string) - `used` (boolean)