In-person payments
Flint takes cards that are tapped, inserted, or swiped. A counter sale is an ordinary Flint order: it has the same payment attempts, tips, manual capture, refunds, receipts, and payouts as an online order, and it shows up beside your online orders in the dashboard.
Two kinds of reader take these payments:
| Reader | What it is | Where your code runs |
|---|---|---|
smart_reader | A Stripe Reader S710 or S700 countertop reader. Flint recommends the S710, which is the S700 with optional 4G/LTE cellular. | Only on your server. Your server sends the reader a payment through Flint, and the reader collects the card. There is no SDK on the point-of-sale device. |
tap_to_pay | An iPhone or Android phone that takes contactless cards and phone wallets with Tap to Pay. | In your app, with the Stripe Terminal SDK. Your server gives the app connection sessions and pays the order through Flint. |
What's supported#
- US only, in USD. The merchant is a US business, the reader's location has a US address, and every amount is in US dollars.
- No offline mode. A reader or phone that can't reach Flint can't take a card. Plan for outages with a payment link or the dashboard's virtual terminal.
- Cards and wallets. The S710 and S700 read chip, contactless, and swipe, with PIN where the card asks for one. Tap to Pay reads contactless cards and phone wallets. It can't read chip-only or offline-PIN cards, so offer another way to pay for those.
- One payment at a time. A reader presents one payment at a time, and a payment is presented on one reader at a time.
- A card-present price. A card on a reader costs 2.99% + 15¢, and Tap to Pay costs 2.99% + 25¢. International cards add 1.50%, and the smallest payment is $0.50. A merchant without a card-present price gets
409 MERCHANT_NOT_READYwith reasonpricing_not_authorizedwhen a payment is presented. See Processing fees. - No saved cards. A card collected on a reader isn't saved for later, and readers can't take
setuprequests.
Tap to Pay on iPhone needs an iPhone XS or later and an entitlement from Apple for your app. Tap to Pay on Android needs an NFC phone that passes Stripe's device checks. Set up Tap to Pay lists what each needs.
Card data never reaches Flint or your server. The reader or phone encrypts the card and sends it to Stripe.
Before you start#
- A location with a complete US address. Create it with Locations:
line1,city,state,postal_code, andcountry: US. Every reader sits at one location, and Stripe requires the address. If the counter sells tracked items, setinventory_allocation_enabled: trueon that location. Setting the flag needscommerce.inventory.allocation.writeas well asmerchants.locations.write; see Inventory. - Credentials that can use readers. An API key needs the scopes
payments.readers.writeto register readers and take payments on them, andpayments.readers.readto list them. Partner apps request the same scopes, and an install token that holds them works with the installed merchant's readers. See API keys and Partner app installs. - A merchant that's ready for card payments, with a card-present price.
- A sandbox to try it in. A sandbox has a simulated S700, so you can build and test everything before you pair hardware. See Test your integration.
Pair a countertop reader#
Plug in the reader and open Settings on its screen to show its pairing code, three words such as puppy-hamster-banana. Then register it at the location where it sits:
curl -X POST https://api.withflintpay.com/v1/readers \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: register-front-counter" \
-d '{
"type": "smart_reader",
"registration_code": "puppy-hamster-banana",
"location_id": "loc_01KEZF7C00CMHRRYA3MV996JB2",
"name": "Front counter"
}'
A pairing code works once, so always send an Idempotency-Key: a retry with the same key returns the same reader, even after a timeout. Flint reads the reader's model and serial_number from Stripe and returns 201 with the reader. A reader keeps its location, so to move it, archive it and register it again.
Merchants can also pair a reader themselves: in the dashboard, open Settings > Readers, choose Pair a reader, and enter the code. The same page renames and archives readers and shows whether each one is online. Tap to Pay phones are listed there but are set up from your app.
GET /v1/readers lists readers, and each active smart reader reports its connectivity as Flint last observed it. Don't block a sale on it: Flint checks the reader itself before it sends a payment.
Set up Tap to Pay#
Register one tap_to_pay reader for each phone that takes payments, at the location where it works:
curl -X POST https://api.withflintpay.com/v1/readers \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: register-ana-iphone" \
-d '{
"type": "tap_to_pay",
"location_id": "loc_01KEZF7C00CMHRRYA3MV996JB2",
"device_id": "dev_01KF4Q6R8T0Y2U4I6O8P0A2S4D",
"name": "Ana'\''s iPhone"
}'
device_id is optional. A device holds at most one active Tap to Pay reader.
What the phone needs#
- iPhone. An iPhone XS or later. Ask Apple for the Tap to Pay on iPhone entitlement for your app, show Apple's "How to Tap" education in the app, and have the merchant accept Apple's Tap to Pay terms with an Apple Account the first time they use it. PIN entry needs iOS 16.4 or later.
- Android. An NFC phone that passes Stripe's device attestation.
- Your app. The Stripe Terminal SDK for iOS or Android.
Give the app a connection session#
The Terminal SDK asks your app for a connection token whenever it connects. Your app asks your server, and your server asks Flint:
curl -X POST https://api.withflintpay.com/v1/readers/rdr_01KF4Q7Y9U1I3O5P7A9S1D3F5G/connection-sessions \
-H "Authorization: Bearer YOUR_API_KEY"
Return data.client_session.stripe.connection_token from the SDK's fetchConnectionToken callback, and pass data.client_session.stripe.location_id, a Stripe location ID, to the SDK's TapToPayConnectionConfiguration. Each call creates a new single-use token. The token is scoped to the reader's location, not to one phone, so your server decides which phone gets a session. Keep your credential on your server, and never ship it in the app. See the Readers reference for the response.
Sell at the counter#
A counter sale has three steps: create the order, pay it on a reader, and wait for the result.
Create the order#
Create an order as you would online. For goods the buyer takes with them, set a handover instead of a delivery destination:
curl -X POST https://api.withflintpay.com/v1/orders \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: counter-order-1042" \
-d '{
"line_items": [
{"type": "variant", "variant_id": "var_01KF4Q1A2B3C4D5E6F7G8H9J0K", "quantity": 1},
{"type": "variant", "variant_id": "var_01KF4Q1B3C4D5E6F7G8H9J0K1M", "quantity": 1}
],
"handover": {"location_id": "loc_01KEZF7C00CMHRRYA3MV996JB2"}
}'
Pay on the reader#
Send action: pay with a reader payment source to the order's pay route. Flint creates an automatic-capture payment for the outstanding balance and presents it on the reader:
curl -X POST https://api.withflintpay.com/v1/orders/ord_01KF4Q9B1N3M5Q7W9E1R3T5Y7U/pay \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: counter-pay-1042-1" \
-d '{
"action": "pay",
"payment_source": {
"credential_type": "reader",
"reader_id": "rdr_01KF4Q2W8E6R0T2Y4U6I8O0P2A",
"tip": {"enabled": true}
},
"expected_outstanding_money": {"amount": 1275, "currency": "USD"}
}'
expected_outstanding_money and expected_version work as they do for any order payment, and versions and write fences explains both. tip.enabled shows the reader's tip screen before the card, and defaults to false.
Flint checks the reader before it sends anything. A refusal at this point means nothing was presented and nothing was charged, so fix the cause and send the request again:
| Response | Meaning |
|---|---|
404 RESOURCE_NOT_FOUND | The reader doesn't exist for this merchant and environment. |
403 INSUFFICIENT_SCOPE | The credential lacks payments.readers.write. |
409 ACTION_NOT_ALLOWED, reason archived | The reader is archived. |
409 ACTION_NOT_ALLOWED, reason reader_offline | The reader can't be reached. Check its power and network. |
409 ACTION_NOT_ALLOWED, reason reader_unavailable | The reader refused the payment before collection started. Check the reader and try again. |
409 OPERATION_IN_PROGRESS | The reader is presenting another payment, or, with reason reader_busy, is completing other work such as a software update or a card left in the slot. Wait for Retry-After and try again. |
Wait for the result#
On a smart reader, the response returns while the buyer is still tapping. The attempt and the payment are processing, is_resumable is false, and there is no pending action:
{
"data": {
"order": {"order_id": "ord_01KF4Q9B1N3M5Q7W9E1R3T5Y7U", "status": "open", "payment_status": "unpaid"},
"order_payment_attempt": {
"order_payment_attempt_id": "opat_01KF4Q9C2M4N6B8V0C2X4Z6L8K",
"status": "processing",
"is_resumable": false,
"payment_intents": [
{"payment_intent_id": "pi_01KF4Q5T7Y9U1I3O5P7A9S1D3F", "status": "processing", "reader_id": "rdr_01KF4Q2W8E6R0T2Y4U6I8O0P2A"}
]
}
}
}
The response is shortened. Learn the outcome from webhooks, or read the order:
| Event | The payment |
|---|---|
payment_intent.succeeded | Was authorized and captured. The order is paid. |
payment_intent.requires_capture | Was authorized and is held for capture. |
payment_intent.payment_failed | Was declined. The payment is back at requires_payment_method and can be tried again. |
payment_intent.canceled | Was canceled, on the reader or through Flint. |
Don't fulfill an order until payment_intent.succeeded or order.paid arrives.
When the buyer pays, the payment intent carries what the card network and your receipt need in payment_source.card.card_present: read_method (contactless, chip, swipe, or swipe_fallback), wallet, cardholder_verification, and the card application's application_name, application_id, and authorization_code. Print your own receipt from these. A swipe_fallback read, a swipe after the chip failed, doesn't shift counterfeit-fraud liability to the issuer.
Declines and retries#
A decline fails the attempt and leaves the payment reusable. Read last_payment_error for the reason: PIN declines have the codes incorrect_pin, pin_try_exceeded, and pin_required, and other declines use the usual codes such as card_declined and insufficient_funds. See Declines and payment attempts.
To try again, or to use another card, confirm the same payment intent with a reader payment source. The retry reuses the same Stripe payment, which guards against charging the buyer twice:
curl -X POST https://api.withflintpay.com/v1/orders/ord_01KF4Q9B1N3M5Q7W9E1R3T5Y7U/pay \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: counter-pay-1042-2" \
-d '{
"action": "confirm_payment_intents",
"payment_intents": [{
"payment_intent_id": "pi_01KF4Q5T7Y9U1I3O5P7A9S1D3F",
"payment_source": {
"credential_type": "reader",
"reader_id": "rdr_01KF4Q2W8E6R0T2Y4U6I8O0P2A"
}
}]
}'
A request with a reader has exactly one payment intent. To present a standalone payment intent on a reader, send the same payment_source to its confirm route:
curl -X POST https://api.withflintpay.com/v1/payment-intents/pi_01KF4Q5T7Y9U1I3O5P7A9S1D3F/confirm \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: counter-confirm-1042-1" \
-d '{
"payment_source": {
"credential_type": "reader",
"reader_id": "rdr_01KF4Q2W8E6R0T2Y4U6I8O0P2A",
"tip": {"enabled": true}
}
}'
If the buyer presses Cancel on the reader, the attempt ends canceled with status_reason: "canceled_on_reader", and you start a new payment when they're ready.
Cancel a payment on the reader#
A cashier at a stuck reader can cancel and take the payment another way. Cancel through the order's payment attempt:
curl -X POST https://api.withflintpay.com/v1/orders/ord_01KF4Q9B1N3M5Q7W9E1R3T5Y7U/payment-attempts/opat_01KF4Q9C2M4N6B8V0C2X4Z6L8K/cancel \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: counter-cancel-1042-1"
For a standalone payment, use POST /v1/payment-intents/{payment_intent_id}/cancel. Flint clears the reader's screen, cancels the Stripe payment, and reports canceled only after Stripe confirms, so no card can be charged afterward. A card that is already authorizing returns 409 ACTION_NOT_ALLOWED with reason in_progress: wait for the outcome. A payment that was already captured returns reason payment_collected: refund it instead.
An attempt on a reader keeps the usual 30-minute window. When it ends, Flint clears the reader and cancels the payment first. If the card was authorized in the meantime, Flint keeps that result instead. A payment that is processing because its outcome isn't known yet isn't ended by the window.
Pay with Tap to Pay#
An order paid on a Tap to Pay reader uses the same request, with the Tap to Pay reader's ID. The tip screen isn't available on Tap to Pay, so send no tip. The response waits on your app: the attempt is requires_action with is_resumable: true and one pending action:
{
"action_type": "card_presentment",
"client_action": {
"stripe": {
"account_id": "acct_1Example",
"publishable_key": "pk_test_Example",
"terminal_payment_intent": {
"client_secret": "pi_3Example_secret_Example",
"stripe_terminal_sdk_call": "collect_and_confirm_payment_intent"
}
}
}
}
- Your server sends the app the
client_secret. The secret only works with a Tap to Pay reader connected for this merchant's location, and only for this payment's amount. - The app passes it to the Terminal SDK's
retrievePaymentIntent, then collects and confirms on the connected Tap to Pay reader withcollectPaymentMethodandconfirmPaymentIntent, orprocessPaymentIntentwhere the SDK provides it. The SDK ignoresaccount_idandpublishable_key. - When the SDK finishes, your server sends
action: "resume"with theorder_payment_attempt_id, with a newIdempotency-Key. For a standalone payment, confirm again with nopayment_source.
Flint reads the outcome. An authorization or capture applies the result, and a payment still processing moves the attempt to processing. If no card was presented or the card was declined, the attempt stays requires_action with the same client secret, and the decline is in last_payment_error, so the app can collect another card.
A decline doesn't fail a Tap to Pay attempt, because the app can still collect on the same payment. Only a success, a cancel, or the 30-minute window ends it. To give up, cancel through Flint. Let Flint, not the SDK, end the payment: a card the SDK charges between attempts is applied to the order, and Flint refunds any excess the order no longer owes.
The client secret appears only in the pending action, and only for 24 hours from the request and while the attempt is requires_action. Lists and webhooks never include it. Payments in mobile apps covers the app side.
Tips#
An order has one tip, and payments can carry it. A buyer can tip on the reader, and a tip can be set when you capture a held payment.
Tip screen on a smart reader. Send tip: {"enabled": true} and the reader shows the merchant's tip options before the card: three percentages, and three fixed amounts when smart tips are on, plus a custom amount. These are the merchant's tipping settings. Percentages apply to the payment's share of the order before tax and charges, so a guest who pays a $25.00 share of a $50.00 check is offered percentages of $25.00. The reader can't preselect default_tip_percent or hide the custom amount, so those settings apply to hosted checkout only.
When the buyer picks a tip, Flint adds it to the payment's amount_money and records it in tip_money. The tip joins the order's tip when the payment is captured. A payment that is canceled, expires, or fails never adds its tip to the order, so one guest's tip never lands on the next guest's card.
- With automatic capture, Flint captures a payment that has the tip screen on itself, once the card is authorized, so its own fee is priced on the tip too. The payment stays
processinguntil that capture succeeds. A held payment staysrequires_capture, and its capture prices the fee. tip.enabledis refused with400 INVALID_REQUESTon a Tap to Pay reader, on an order with arequested_tip, and on a payment that already carriestip_money. An order takes its tip one way: either a requested tip, or tips carried by its payments.- On split checks, each card can tip. A guest who pays $25.00 and tips $5.00 and a guest who pays the other $25.00 and tips $4.00 leave a $50.00 order with a $9.00 tip, a total of $59.00, and the order paid.
Tips and charges has the rules for each case.
Hold and capture#
A restaurant tab or a service quote often ends at a different amount, plus a tip the guest writes on the slip. Hold the card first, and capture the final amount later.
Create the order's payment with POST /v1/payment-intents, order_id, payment_options: ["card_present"], and capture_method: "manual". With no amount_money, it covers the outstanding balance. Add request_overcapture: true when the final amount plus the tip can be more than the hold:
curl -X POST https://api.withflintpay.com/v1/payment-intents \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: table-6-hold" \
-d '{
"order_id": "ord_01KF4Q9B1N3M5Q7W9E1R3T5Y7U",
"payment_options": ["card_present"],
"capture_method": "manual",
"request_overcapture": true
}'
Then present it on the reader with the order's confirm_payment_intents action and a reader payment source, as in the retry example above. The payment becomes requires_capture (payment_intent.requires_capture).
When the check closes, capture the final amount and the tip in one charge:
curl -X POST https://api.withflintpay.com/v1/payment-intents/pi_01KF4Q5T7Y9U1I3O5P7A9S1D3F/capture \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Idempotency-Key: table-6-capture" \
-d '{
"final_amount_money": {"amount": 6200, "currency": "USD"},
"tip_money": {"amount": 1200, "currency": "USD"}
}'
- A held card can be captured once. Whatever the capture doesn't collect is released.
tip_moneyreplaces any tip the payment carries, including one the buyer chose on the reader.- On an order,
final_amount_moneycan't exceed the order's amount for that payment. Only the tip can go above the hold, and only whenovercapture.statusisavailable. Without overcapture, a capture collects at mostcapturable_money, so leave room for the tip by setting arequested_tipbefore you hold the card. - Card-present overcapture is for US Visa, Mastercard, American Express, and Discover cards, at merchant categories such as restaurants, bars, salons, and spas. It allows the larger of 50% of the authorization or $50.00 more. Read
overcapture.statusandovercapture.maximum_capturable_moneyafter the hold. Flint reports what the card allows, and the merchant follows the card network's rules. - Stripe releases an uncaptured card-present hold after two days, and an order's hold ends sooner when its resource guarantee does, at most 24 hours after the attempt starts. Read
authorization_expires_at, and capture or cancel before then. A new capture after it is refused and nothing is charged. See Authorization expiry.
Manual capture lists every bound and error.
Carry-out sales#
For a counter sale where the buyer leaves with the goods, set the order's handover to the location. A handover replaces the delivery selection, so paying needs no delivery quote or address, and tax is figured as a sale made at the location. Tracked items take stock from that location, and the order is paid in person or online.
When the order is paid, Flint creates one fulfillment with type: handover at the location and completes it right away. You receive fulfillment.created and fulfillment.completed, and the buyer gets no fulfillment email. See Sell for carry-out with a handover and Fulfill and ship orders.
Refunds and receipts#
Refund a card-present payment as you refund any payment, with POST /v1/refunds. Stripe returns the money to the card with no reader or card present. Partial refunds, line-item refunds, and refund_platform_fee all apply, and a refund returns the rest of the payment before the tip it carried. See Refunds.
Flint's receipts, the email from send-receipt, the receipt PDF, and the hosted receipt page, show the entry method and wallet (for example "Contactless, Apple Pay"), the card brand and last four digits, the card application, the authorization code, how the cardholder was verified, the reader location, and the tip. Readers don't print or email. Collect an email and send it as receipt_email, or call POST /v1/orders/{order_id}/send-receipt, or print your own from payment_source.card.card_present.
Disputes use the usual dispute flow.
Split checks#
Each guest's payment is its own attempt. Present them one at a time: create each payment for the guest's share, then confirm it on the reader. A request with a reader takes one payment intent, so a second guest starts a new attempt. Send completion_behavior: "partial_payment" when the payment doesn't pay the whole balance. Order payments has the request.
When something goes wrong#
Server-driven readers have no offline mode, so these cases are about outages, not about taking cards without a connection.
| What happened | What Flint does | What you do |
|---|---|---|
| The reader is offline when you send the payment | 409 ACTION_NOT_ALLOWED, reason reader_offline. Nothing was sent. | Check the reader's power and network. Meanwhile, take the payment with a payment link or the virtual terminal. |
| The reader is busy | 409 OPERATION_IN_PROGRESS with Retry-After. Nothing was sent. | Wait, and send again. |
| The reader loses its connection mid-payment | The payment stays processing until Flint reads a final result from Stripe. The order refuses another payment until then, so a second card can't be charged while the first might have gone through. | Wait for the event. To give up, cancel: Flint cancels the Stripe payment unless the card was already charged. |
| A request times out | Flint checks the reader and the payment before it sends again, so a retry doesn't charge twice. | Retry with the same Idempotency-Key. |
| The buyer cancels on the reader | The attempt ends canceled with reason canceled_on_reader. | Start a new payment when they're ready. |
| The reader goes offline or becomes busy after the attempt started, before a card was read | The attempt ends failed with status_reason: "reader_unavailable", and the payment can be presented again. | Check the reader, then present again. |
| A webhook is missed | Flint reads every payment that has been on a reader for more than two minutes, and clears a stuck reader screen. | Read the order or payment intent if your webhook handler was down. |
Test your integration#
Test in a sandbox before you go live. A sandbox reader takes no real cards, and nothing in a sandbox moves money.
Simulated reader. Register a reader with registration_code: "simulated-s700". It has is_simulated: true and is reported as an S700, and needs a card presented by simulate. Send a payment to it as above, then present a test card:
curl -X POST https://api.withflintpay.com/v1/readers/rdr_01KF4Q2W8E6R0T2Y4U6I8O0P2A/simulate \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_TEST_KEY" \
-d '{"outcome": "approved", "card_brand": "visa", "tip_money": {"amount": 300, "currency": "USD"}}'
outcome is approved, declined, or insufficient_funds. card_brand is optional. tip_money is the tip the buyer picks, and is allowed only when the payment was sent with the tip screen on. simulate needs a test key and a simulated reader with a payment presented on it.
A physical S710 or S700 in a sandbox. A real reader pairs in a sandbox and takes Stripe's physical test card. The amount's cents choose the result:
| Cents | Result |
|---|---|
.00 | Approved. |
.01 | Declined with call_issuer. |
.02, .03 | The reader asks for a PIN. Enter 1234, or any four digits for .03. |
.05 | Declined. |
.55 | Declined, incorrect_pin. |
.65 | Declined, withdrawal limit. |
.75 | Declined, pin_try_exceeded. |
Tap to Pay. Use the Terminal SDK's simulated reader (simulated: true when discovering readers) with a sandbox connection session, and set the test card in the SDK's simulator configuration. Phone wallets such as Apple Pay and Google Pay can't be tested in a sandbox.
Testing and the test cards reference list the rest. Resetting or archiving a sandbox archives its readers and unregisters them from Stripe, so a physical reader paired in a sandbox can be paired again at once.
Take in-person payments for your customers#
A partner app's install token can register readers and take payments for the merchants that installed it, within the scopes the merchant granted. Readers belong to the merchant and stay when the app is uninstalled.
- Platform fees.
platform_feeworks on card-present payments as it does online: on payment intent creation, and onpaywith a reader. A tip on the reader raises the amount the fee cap is figured on. When you hold first and capture later, sendplatform_feewith the capture of a standalone payment, so the fee is set on the final amount plus the tip. A payment that belongs to an order takes the fee when you create it. See Platform fees. - Fixed fee part. A fee cap can include a fixed amount per payment, such as "up to 1% + $0.30 of each payment, never more than $5.00", which suits small tickets.
- Webhooks. Partner apps that hold
payments.readers.readreceivereader.created,reader.updated, andreader.archivedfor their installed merchants.
Errors#
| Code | Reason | When |
|---|---|---|
403 INSUFFICIENT_SCOPE | The credential lacks payments.readers.write, or a device_id was sent without accounts.devices.read. | |
409 ACTION_NOT_ALLOWED | configuration_required | The reader's or handover's location isn't active with a complete address. |
409 ACTION_NOT_ALLOWED | reader_offline | The smart reader isn't reachable. |
409 ACTION_NOT_ALLOWED | reader_unavailable | The reader refused the payment before collection started. The payment stays available for another attempt. |
409 ACTION_NOT_ALLOWED | archived | The reader is archived. |
409 ACTION_NOT_ALLOWED | reader_type_not_supported | A connection session for a smart reader. |
409 ACTION_NOT_ALLOWED | in_progress | A cancel while a card is authorizing. |
409 ACTION_NOT_ALLOWED | payment_collected | A cancel after capture. Refund it. |
409 OPERATION_IN_PROGRESS | reader_busy | The reader is completing work outside this payment, such as a software update. A reader presenting another payment returns the same code, with that payment in blocking_resources. |
409 RESOURCE_IN_USE | Archiving a reader with a payment on it, or a location or device that active readers use. | |
409 LIMIT_EXCEEDED | A capture above what the hold can collect. | |
409 MERCHANT_NOT_READY | pricing_not_authorized | The merchant has no card-present price. |
The Readers reference lists the errors for registering and managing readers.