Skip to main content
These endpoints are implemented and verified against the DSI sandbox (payment created with a real link, and status closed by webhook). The final public callback host is still pending for production, which is why the group is still tagged Coming soon.
A channel (POS, kiosk, web, or app) uses these endpoints to charge through PayBridge. The channel only sends the transaction data (order, amount, method, storeId, terminalId); PayBridge resolves the provider, creates the payment, and returns a payment link for the channel to show the customer. The final status arrives through the status webhook. The merchant configuration (credentials, methods, terminals) already lives in the provider via the config sync, which is why the charge travels lean.

Authentication

string
required
A vendor-scoped Fire API key with the paybridge:charge scope. accountId and vendorId are derived from the key; a key without a vendor returns 403.
Every response is wrapped in { "success": true, "data": { … } }.

Charges and attempts

Charge (intent)

The charge for one order: total amount, currency, store, terminal, and channel. The channel creates it once.

Attempt

Each payment attempt inside the charge. It takes a slot: one slot per method in a split payment, and a new attempt in the same slot when you retry.
Charge statuses: Attempt statuses:

Flow

1

Create the charge

The channel calls POST /intents with the order, amount, method, and its storeId/terminalId. PayBridge creates the payment at the provider and returns the paymentLink in the first attempt.
2

Show the link

The channel shows the paymentLink (redirect, QR, or iframe) for the customer to pay.
3

Learn the result

Fire receives the provider status through the webhook and updates the attempt and the charge. The channel reads it with GET /intents/{intentId}.
4

Close the case

If the customer doesn’t pay, cancel the attempt. If the payment is already approved, refund it. If it fails or money is missing, add another attempt with POST /intents/{intentId}/pay.

Endpoints


Create charge

POST /api/v1/external/paybridge/intents
string
required
The order id in the channel’s system (max. 80 characters). This is the idempotency key: sending the same value again returns the existing charge instead of duplicating it.
string
required
Payment method code in Fire (for example deuna, rutpay). It must be active in the catalog, otherwise the call returns 400.
number
required
Total amount to charge, in the currency’s major unit (for example 19.90).
string
required
Three-letter ISO 4217 currency (USD, CLP, COP, ARS, VES, BRL).
string
required
UUID of the store in Fire. It travels to the provider as branchOffice.
string
required
Id of the POS terminal or the kiosk device. It travels to the provider as pointOfSale.
string
required
Channel that originates the charge: POS, KIOSK, WEB, or APP.
string
Country of the charge (ISO alpha-2). You can omit it when the method belongs to a single country: Fire derives it. For multi-country methods it is required; without it the attempt ends up failed because the country connection can’t be resolved.
object
Optional payer data. It is forwarded to the provider when required.
object
The charge with all its attempts.
If the provider rejects the payment creation, the response is still 201: the charge exists and its attempt is failed with the reason in errorDescription. Check the attempt status, not just the HTTP code.

Get charge

GET /api/v1/external/paybridge/intents/{intentId} Returns the local status of the charge and all its attempts. It does not call the provider: the status is kept up to date by the webhook.
string
required
UUID of the charge returned when it was created. You only see charges of the API key’s account; a charge from another account returns 404.
object
The same object returned by the creation call.

Add an attempt

POST /api/v1/external/paybridge/intents/{intentId}/pay It covers two cases: retrying a method that failed and split payments (several methods on the same order).
string
required
UUID of the charge.
string
required
Method for the new attempt.
number
Amount of the attempt. If omitted, it uses what’s left (amountTotal - amountPaid).
number
Slot the attempt belongs to. If omitted, a new slot is opened (split payment). To retry, send the slot of the attempt that failed. A slot with an active attempt returns 400.
object
The updated charge, with the new attempt inside attempts.
A closed charge (succeeded, canceled, or reversed) doesn’t accept new attempts: it returns 400.

Cancel attempt

POST /api/v1/external/paybridge/attempts/{attemptId}/cancel Cancels an active attempt whose link hasn’t been paid yet (or expired).
string
required
Id of the attempt to cancel.
object
The updated charge; the attempt becomes canceled.
The provider only accepts the cancellation once the link is already waiting for payment (waitingPayment). A freshly created attempt usually answers “cancellation does not apply”: in that case Fire does not mark the attempt as canceled and returns the error, so a payment that is still alive on the provider side isn’t treated as canceled.

Refund attempt

POST /api/v1/external/paybridge/attempts/{attemptId}/refund Refunds an already approved attempt (succeeded).
string
required
Id of the approved attempt.
object
The updated charge; the attempt moves to solving until the provider confirms.
Full refunds only. The provider doesn’t support partial amounts: sending amount in the body returns 400. The refund is asynchronous — the attempt stays in solving and becomes refunded when the refundPayment webhook arrives (or stays in solving with the reason if refundFailed arrives).

Errors

Every error carries { "success": false, "error": "…", "message": "…" }.

Status webhook

How the provider tells Fire that the payment was approved, canceled, or refunded.

Config sync to DSI

How the merchant configuration reaches the provider so the charge stays lean.

Methods supported per country

Which methods each country can charge, and with which code.

Method availability

Which method is on in each store, device, and channel.