Payments

12 endpoints. Each needs an API key or OAuth token with the scope shown; the key already names its store, so paths start at /v1/store. Generated from the live contract; also in openapi.json.

Every way the store can get paid: ShopFast Pay status, gateways, manual methods, plugins, health, order and rules

GET/v1/store/payments/overview

Or name the store: GET /v1/stores/{storeId}/payments/overview

payments:readrole: payments:readgetPaymentsOverview

Response GetPaidOverview

paymentModelPaymentModelrequired
paySellerPayStatusrequired
methodsGetPaidMethod[]required
rulesPaymentMethodRulesrequired
testModePaymentsTestModerequired
feesFeeSchedulerequired
currencyCurrencyCoderequired
allowedModelsPaymentModel[]required
pricesIncludeTaxboolean
homeTaxTaxRate

Example

curl "https://api.shopfa.st/v1/store/payments/overview" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY"

const res = await fetch('https://api.shopfa.st/v1/store/payments/overview', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
  },
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "GET",
    "https://api.shopfa.st/v1/store/payments/overview",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("GET", "https://api.shopfa.st/v1/store/payments/overview", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

ShopFast Pay for this store: the platform mode, the application, limits, reserve and payout hold

GET/v1/store/payments/shopfast-pay

Or name the store: GET /v1/stores/{storeId}/payments/shopfast-pay

payments:readrole: payments:readgetShopFastPayStatus

Response SellerPayStatus

modePayAccessModerequired
statePayAccessStaterequired
usablebooleanrequired
headlinestringrequired
applicationPayApplication | nullrequired
limitsPayLimitsrequired
usedMinorMinorUnitsrequired
effectiveReserveBpsBpsrequired
payoutHoldobjectrequired
- heldbooleanrequired
- reasonstringrequired
- sinceTimestamp | nullrequired
fallbackPayFallbackrequired
canApplybooleanrequired
currencyCurrencyCoderequired

Example

curl "https://api.shopfa.st/v1/store/payments/shopfast-pay" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY"

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
  },
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "GET",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("GET", "https://api.shopfa.st/v1/store/payments/shopfast-pay", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

The order buyers see ways to pay in, and per-method country and order total rules

PUT/v1/store/payments/rules

Or name the store: PUT /v1/stores/{storeId}/payments/rules

payments:writerole: payments:writesavePaymentRules

Body

order"shopfast_pay" | "sandbox" | "stripe" | "paypal" | "btcpay" | "manual" | "plugin" | "crypto_direct" | "stripe_keys" | "paypal_keys" | "square" | "mollie" | "razorpay" | "paystack" | "nowpayments" | "cryptomus" | "paypal_email" | "shopify" | "paddle" | "heleket" | "sumup" | "authorize_net" | "nmi" | "skinloop" | "cashapp" | "paypal_ff" | "gift_codes"[]required
rulesobjectrequired

Response PaymentMethodRules

orderGatewayProvider[]required
rulesobjectrequired

Example

curl -X PUT "https://api.shopfa.st/v1/store/payments/rules" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "order": [
    "shopfast_pay"
  ],
  "rules": {}
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/rules', {
  method: 'PUT',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "order": [
      "shopfast_pay"
    ],
    "rules": {}
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "PUT",
    "https://api.shopfa.st/v1/store/payments/rules",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "order": [
        "shopfast_pay"
      ],
      "rules": {}
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("PUT", "https://api.shopfa.st/v1/store/payments/rules", strings.NewReader(`{
  "order": [
    "shopfast_pay"
  ],
  "rules": {}
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Turn store-wide test mode on for a few hours (checkouts run on simulated payments and are marked test) or off

PUT/v1/store/payments/test-mode

Or name the store: PUT /v1/stores/{storeId}/payments/test-mode

payments:writerole: payments:writesetPaymentsTestMode

Body

onbooleanrequired
hoursnumber

Response PaymentsTestMode

onbooleanrequired
untilTimestamp | nullrequired

Example

curl -X PUT "https://api.shopfa.st/v1/store/payments/test-mode" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "on": false,
  "hours": 24
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/test-mode', {
  method: 'PUT',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "on": false,
    "hours": 24
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "PUT",
    "https://api.shopfa.st/v1/store/payments/test-mode",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "on": False,
      "hours": 24
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("PUT", "https://api.shopfa.st/v1/store/payments/test-mode", strings.NewReader(`{
  "on": false,
  "hours": 24
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Save the ShopFast Pay application as a draft (starts one when there is none)

PUT/v1/store/payments/shopfast-pay/application

Or name the store: PUT /v1/stores/{storeId}/payments/shopfast-pay/application

payments:writerole: payments:writesavePayApplication

Body

answersobjectrequired
- categories"game_keys" | "game_accounts" | "software" | "courses" | "memberships" | "gift_cards" | "digital_art" | "services" | "other"[]
- productExamplesstring
- linksstring[]
- monthlyVolumeMinorinteger | null
- averageOrderMinorinteger | null
- buyerCountriesstring[]
- refundPolicystring
- yearsSelling"new" | "under_1" | "1_3" | "3_plus" | null
- discordstring | null
- telegramstring | null
- websitestring | null
- entityType"individual" | "business" | null
- businessNamestring | null
kycobjectrequired
- legalNamestring
- countrystring | null
- dateOfBirthstring | null

Response PayApplication

idPayApplicationIdrequired
statusPayApplicationStatusrequired
answersPayApplicationDraftrequired
kycPayKycDraftrequired
documentsPayDocument[]required
infoRequeststringrequired
decisionReasonstringrequired
submittedAtTimestamp | nullrequired
decidedAtTimestamp | nullrequired
createdAtTimestamprequired
updatedAtTimestamprequired
eventsPayEvent[]required

Example

curl -X PUT "https://api.shopfa.st/v1/store/payments/shopfast-pay/application" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "answers": {},
  "kyc": {}
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay/application', {
  method: 'PUT',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "answers": {},
    "kyc": {}
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "PUT",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay/application",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "answers": {},
      "kyc": {}
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("PUT", "https://api.shopfa.st/v1/store/payments/shopfast-pay/application", strings.NewReader(`{
  "answers": {},
  "kyc": {}
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Attach a finished upload (purpose file: PDF, PNG, JPEG or WebP up to 15 MB) to the application

POST/v1/store/payments/shopfast-pay/application/documents

Or name the store: POST /v1/stores/{storeId}/payments/shopfast-pay/application/documents

payments:writerole: payments:writeaddPayDocument

Body

uploadIdupl_…required
kind"identity" | "proof_of_address" | "business_registration" | "other"required

Response PayApplication

idPayApplicationIdrequired
statusPayApplicationStatusrequired
answersPayApplicationDraftrequired
kycPayKycDraftrequired
documentsPayDocument[]required
infoRequeststringrequired
decisionReasonstringrequired
submittedAtTimestamp | nullrequired
decidedAtTimestamp | nullrequired
createdAtTimestamprequired
updatedAtTimestamprequired
eventsPayEvent[]required

Example

curl -X POST "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "uploadId": "upl_0123456789abcdefghjk",
  "kind": "identity"
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "uploadId": "upl_0123456789abcdefghjk",
    "kind": "identity"
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "POST",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "uploadId": "upl_0123456789abcdefghjk",
      "kind": "identity"
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("POST", "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents", strings.NewReader(`{
  "uploadId": "upl_0123456789abcdefghjk",
  "kind": "identity"
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Remove a document from an application that is still open

DELETE/v1/store/payments/shopfast-pay/application/documents/{documentId}

Or name the store: DELETE /v1/stores/{storeId}/payments/shopfast-pay/application/documents/{documentId}

payments:writerole: payments:writeremovePayDocument

Parameters

documentIdpdoc_…pathrequired

Response PayApplication

idPayApplicationIdrequired
statusPayApplicationStatusrequired
answersPayApplicationDraftrequired
kycPayKycDraftrequired
documentsPayDocument[]required
infoRequeststringrequired
decisionReasonstringrequired
submittedAtTimestamp | nullrequired
decidedAtTimestamp | nullrequired
createdAtTimestamprequired
updatedAtTimestamprequired
eventsPayEvent[]required

Example

curl -X DELETE "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents/pdoc_0123456789abcdefghjk" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY"

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents/pdoc_0123456789abcdefghjk', {
  method: 'DELETE',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
  },
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "DELETE",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents/pdoc_0123456789abcdefghjk",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("DELETE", "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/documents/pdoc_0123456789abcdefghjk", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

documentId

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Owner only: send the application to ShopFast for review (or turn ShopFast Pay on at once when it is open to all)

POST/v1/store/payments/shopfast-pay/application/submit

Or name the store: POST /v1/stores/{storeId}/payments/shopfast-pay/application/submit

payments:writerole: payments:writesubmitPayApplication

Body

answersobjectrequired
- categories"game_keys" | "game_accounts" | "software" | "courses" | "memberships" | "gift_cards" | "digital_art" | "services" | "other"[]
- productExamplesstring
- linksstring[]
- monthlyVolumeMinorinteger | null
- averageOrderMinorinteger | null
- buyerCountriesstring[]
- refundPolicystring
- yearsSelling"new" | "under_1" | "1_3" | "3_plus" | null
- discordstring | null
- telegramstring | null
- websitestring | null
- entityType"individual" | "business" | null
- businessNamestring | null
kycobjectrequired
- legalNamestring
- countrystring | null
- dateOfBirthstring | null

Response SellerPayStatus

modePayAccessModerequired
statePayAccessStaterequired
usablebooleanrequired
headlinestringrequired
applicationPayApplication | nullrequired
limitsPayLimitsrequired
usedMinorMinorUnitsrequired
effectiveReserveBpsBpsrequired
payoutHoldobjectrequired
- heldbooleanrequired
- reasonstringrequired
- sinceTimestamp | nullrequired
fallbackPayFallbackrequired
canApplybooleanrequired
currencyCurrencyCoderequired

Example

curl -X POST "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/submit" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "answers": {},
  "kyc": {}
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay/application/submit', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "answers": {},
    "kyc": {}
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "POST",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/submit",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "answers": {},
      "kyc": {}
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("POST", "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/submit", strings.NewReader(`{
  "answers": {},
  "kyc": {}
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Answer the reviewer's question; the application goes back into review

POST/v1/store/payments/shopfast-pay/application/reply

Or name the store: POST /v1/stores/{storeId}/payments/shopfast-pay/application/reply

payments:writerole: payments:writereplyPayApplication

Body

messagestringrequired

Response PayApplication

idPayApplicationIdrequired
statusPayApplicationStatusrequired
answersPayApplicationDraftrequired
kycPayKycDraftrequired
documentsPayDocument[]required
infoRequeststringrequired
decisionReasonstringrequired
submittedAtTimestamp | nullrequired
decidedAtTimestamp | nullrequired
createdAtTimestamprequired
updatedAtTimestamprequired
eventsPayEvent[]required

Example

curl -X POST "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/reply" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "message": "string"
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay/application/reply', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "message": "string"
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "POST",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/reply",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "message": "string"
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("POST", "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/reply", strings.NewReader(`{
  "message": "string"
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Withdraw an open application

POST/v1/store/payments/shopfast-pay/application/withdraw

Or name the store: POST /v1/stores/{storeId}/payments/shopfast-pay/application/withdraw

payments:writerole: payments:writewithdrawPayApplication

Response SellerPayStatus

modePayAccessModerequired
statePayAccessStaterequired
usablebooleanrequired
headlinestringrequired
applicationPayApplication | nullrequired
limitsPayLimitsrequired
usedMinorMinorUnitsrequired
effectiveReserveBpsBpsrequired
payoutHoldobjectrequired
- heldbooleanrequired
- reasonstringrequired
- sinceTimestamp | nullrequired
fallbackPayFallbackrequired
canApplybooleanrequired
currencyCurrencyCoderequired

Example

curl -X POST "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/withdraw" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY"

const res = await fetch('https://api.shopfa.st/v1/store/payments/shopfast-pay/application/withdraw', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
  },
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "POST",
    "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/withdraw",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("POST", "https://api.shopfa.st/v1/store/payments/shopfast-pay/application/withdraw", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Order limits per payment method: yours, ShopFast's caps for your currency and what checkout enforces

GET/v1/store/payments/limits

Or name the store: GET /v1/stores/{storeId}/payments/limits

payments:readrole: payments:readgetPaymentLimits

Response PaymentLimitsView

limitsMethodLimitsrequired
capsobjectrequired
effectiveEffectiveMethodLimitsrequired
currencyCurrencyCoderequired
offeredLimitedMethod[]required
clampedLimitedMethod[]required

Example

curl "https://api.shopfa.st/v1/store/payments/limits" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY"

const res = await fetch('https://api.shopfa.st/v1/store/payments/limits', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
  },
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "GET",
    "https://api.shopfa.st/v1/store/payments/limits",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("GET", "https://api.shopfa.st/v1/store/payments/limits", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.

Set the smallest and largest order each kind of payment takes, and the card limit for first orders (clamped to ShopFast's caps)

PUT/v1/store/payments/limits

Or name the store: PUT /v1/stores/{storeId}/payments/limits

payments:writerole: payments:writesavePaymentLimits

Body

methodsobject
newBuyerCardMaxMinorinteger | null

Response PaymentLimitsView

limitsMethodLimitsrequired
capsobjectrequired
effectiveEffectiveMethodLimitsrequired
currencyCurrencyCoderequired
offeredLimitedMethod[]required
clampedLimitedMethod[]required

Example

curl -X PUT "https://api.shopfa.st/v1/store/payments/limits" \
  -H "Authorization: Bearer $SHOPFAST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "methods": {},
  "newBuyerCardMaxMinor": null
}'

const res = await fetch('https://api.shopfa.st/v1/store/payments/limits', {
  method: 'PUT',
  headers: {
    Authorization: `Bearer ${process.env.SHOPFAST_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "methods": {},
    "newBuyerCardMaxMinor": null
  }),
});
if (!res.ok) throw new Error((await res.json()).detail);
const data = await res.json();

import os, requests

res = requests.request(
    "PUT",
    "https://api.shopfa.st/v1/store/payments/limits",
    headers={"Authorization": f"Bearer {os.environ['SHOPFAST_API_KEY']}"},
    json={
      "methods": {},
      "newBuyerCardMaxMinor": None
    },
)
res.raise_for_status()
data = res.json()

req, _ := http.NewRequest("PUT", "https://api.shopfa.st/v1/store/payments/limits", strings.NewReader(`{
  "methods": {},
  "newBuyerCardMaxMinor": null
}`))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPFAST_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)

Try it with your key

API base URLAPI key or token

Body

Use a test key on a development store. The key stays in this tab (sessionStorage) and is sent only to the base URL above.