> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.recurrente.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.recurrente.com/_mcp/server.

# Crear un comando de terminal

POST https://app.recurrente.com/api/terminal_session_commands
Content-Type: application/json

Envía un comando de cobro a una terminal POS. Recurrente crea un checkout y lo despacha a la terminal indicada. Si ya existe un comando activo con el mismo `external_id`, retorna el comando existente en vez de crear uno nuevo (idempotencia).

Cuando la terminal recibe el comando, muestra automáticamente la pantalla de cobro para que el cliente pague con tarjeta.

**Usa una llave LIVE para una terminal física.** Una llave TEST se rechaza con `403 terminal_test_key_requires_sandbox`, antes de crear el checkout o mover dinero.

La terminal debe estar en **Modo espera** y reportando disponibilidad. Si no lo está, la API responde `409` con `code: terminal_not_in_standby` sin crear un checkout nuevo. Los reintentos con un `external_id` existente conservan la idempotencia y retornan el comando original. Una respuesta exitosa incluye `terminal_availability`.

### Flujo

1. Tu sistema envía `POST /api/terminal_session_commands` con el monto, moneda y terminal.
2. Recurrente crea un checkout y un comando en estado `pending`.
3. La terminal levanta el comando y lo pasa a `dispatched`.
4. El cliente paga en la terminal.
5. Recibes un webhook `intent.succeeded` con el resultado; las cuentas anteriores al cambio también conservan `payment_intent.succeeded`.

También puedes consultar el comando con `GET /api/terminal_session_commands/{random_id}`. Los estados definitivos son `canceled`, `superseded`, `consumed` y `failed`; `pending`, `dispatched` y `cancel_requested` todavía pueden cambiar.

### Idempotencia

Si envías dos requests con el mismo `external_id` dentro de la misma cuenta, el segundo retorna el comando original sin crear uno duplicado. Dos cuentas distintas pueden usar el mismo `external_id`. Esto te permite reintentar de forma segura.

### Superseding

Si envías un nuevo comando a la misma terminal (con un `external_id` diferente), los comandos anteriores pendientes se marcan como `superseded` y la terminal solo procesa el más reciente.

### Meses sin intereses (installments)

Si quieres que el cobro se procese en cuotas, envía `installments` con el número de meses. Solo aplica a cobros en `GTQ` y los valores permitidos son `3`, `6`, `12` o `18` (algunas cuentas tienen configuraciones distintas). Si la tarjeta del cliente no soporta la opción elegida, el cobro se rechaza con `unsupported_installments`.

### Pantallas post-pago

Por defecto, después de un pago exitoso la terminal muestra las pantallas para solicitar NIT, correo y teléfono. Envía `show_post_payment_screens: false` para omitirlas y volver automáticamente a Modo espera. Recurrente emite la factura como C/F cuando corresponde y adelanta el webhook y los correos que normalmente esperan a que el comprador termine esas pantallas.

Si el monto y la configuración de facturación hacen obligatorio un NIT válido, Recurrente conserva las pantallas aunque envíes `false`.

### NIT del comprador

Si tu sistema ya conoce el NIT, envíalo en `tax_id`. La terminal se salta la pantalla que lo pide y abre directo la de comprobantes, con la factura ya emitida a ese NIT y el comprobante listo para imprimir con el NIT incluido. Si el NIT no es válido se ignora y la pantalla se muestra igual, para que el cajero lo corrija.

### Impresión automática del comprobante

Envía `print_receipt: true` para mandar el comprobante de pago a la impresora una vez que el cobro sea exitoso. La instrucción es best-effort: el resultado de impresión no se expone por API y una impresora sin papel, ocupada o con error no revierte el pago ni retrasa `intent.succeeded`.

### Cuentas conectadas

Para originar el cobro desde una plataforma y registrarlo en una cuenta hija:

1. Autentica el request con la llave LIVE de la plataforma en `X-SECRET-KEY` y envía el ID `ac_...` de la cuenta hija en `X-ACCOUNT-ID`.
2. Obtén el `terminal_id` público (`trm_...`) en el panel de la cuenta hija, en **POS → detalle de la terminal**, y guárdalo en tu configuración. Actualmente no existe un endpoint público para listar terminales.
3. Confirma que el dispositivo inició sesión en esa misma cuenta hija y está en **Modo espera**. Un pinpad emparejado con la plataforma es invisible para la hija (y viceversa).
4. Envía el comando con `terminal_id`, monto, moneda y un `external_id` único de tu sistema. La respuesta incluye el `id` del comando (`tsc_...`), `checkout_id`, `status` y `terminal_availability`.

El checkout, el pago y la factura se crean bajo la cuenta hija. La
plataforma recibe `intent.succeeded` con `connected: true` y el
`account_id` de la hija; si la hija también tiene un webhook endpoint,
Recurrente entrega el evento a ambos. Usa `checkout.metadata.external_id`
para conciliar la orden original, `checkout.metadata.terminal_id` para
identificar el dispositivo y `tax_invoice_url` para recuperar la factura
cuando exista.

Cuando algo no calza, el 404 incluye un `code` que identifica cuál de las tres cosas falta:

| `code`                        | Qué revisar                                                                       |
| ----------------------------- | --------------------------------------------------------------------------------- |
| `connected_account_not_found` | La cuenta que enviaste no está conectada a la tuya (o es nieta, no hija directa). |
| `terminal_not_found`          | La terminal no está asociada a la cuenta que va a cobrar.                         |
| `connected_account_mismatch`  | Enviaste `account_id` de una hermana distinta a la del header `X-ACCOUNT-ID`.     |
| `recipient_not_found`         | El `recipient_id` de un `transfer_setup` no es tu cuenta ni una hija conectada.   |

Reference: https://docs.recurrente.com/referencia-api/api-reference/terminal-session-commands/create-terminal-session-command

## Authentication

- `X-SECRET-KEY` header (required) — Tu clave secreta de API. Una llave de cuenta (`sk_live_...`, `sk_test_...`) opera sobre su propia cuenta y, con `X-ACCOUNT-ID`, sobre sus cuentas conectadas. La llave también fija el ambiente: una `sk_test_` solo lista y resuelve objetos de prueba (`live_mode: false`) y una `sk_live_` solo objetos reales. Un ID del otro ambiente responde `404` (`401` en `/customers`). Una llave de organización (`sk_org_live_...`, `sk_org_test_...`) alcanza todas las cuentas de una organización y solo sirve para leer: saldos, movimientos y reportes. Para operar sobre una cuenta debe nombrarla con `X-ACCOUNT-ID`; omitirlo en una lectura devuelve todas las cuentas de la organización. Cualquier otro endpoint responde `403` con `code: organization_key_unsupported`.

## Request

### Body (application/json)

This endpoint expects an object.

- `terminal_id` (string, required) — ID público `trm_...` de la terminal POS donde se enviará el cobro. Cópialo desde **POS → detalle de la terminal** en la cuenta que va a cobrar; actualmente no existe un endpoint público para listar terminales.
- `currency` (enum, required) — Moneda del cobro
  - Allowed values: `GTQ`, `USD`
- `external_id` (string, required) — ID único de tu sistema para este cobro dentro de la cuenta autenticada. Se usa para idempotencia — si envías el mismo `external_id` dos veces en esa cuenta, no se crea un duplicado.
- `amount_in_cents` (integer, optional) — Monto a cobrar en centavos. Envía `amount_in_cents`, `amount` o `items` — solo uno.
- `amount` (double, optional) — Monto a cobrar en unidades (ej. 50.00). Alternativa a `amount_in_cents`.
- `items` (list of TerminalSessionCommandsPostRequestBodyContentApplicationJsonSchemaItemsItems, optional) — Cobra productos existentes en vez de un monto suelto: cada item referencia un precio y el total se calcula sumando los items. No se puede combinar con `amount_in_cents`/`amount` ni con `description` (cada producto ya tiene nombre). Solo productos de pago único, todos en la moneda del cobro (`currency`). Con una cuenta conectada como comercio de registro, los precios deben pertenecer a esa cuenta.
- `description` (string, optional) — (Opcional) Concepto del cobro, por ejemplo el número de orden de tu sistema. Aparece en el recibo del cliente y en la actividad del comercio (ej. "Pago POS por Orden #1234"). Si se omite, el cobro se muestra sin concepto, como un pago rápido. No se puede combinar con `items`.
- `installments` (enum, optional) — Número de meses sin intereses. Solo válido con `currency: GTQ`. Valores permitidos por defecto `[3, 6, 12, 18]` (puede variar por cuenta).
  - Allowed values: `3`, `6`, `12`, `18`
- `show_post_payment_screens` (boolean, optional, default: true) — Muestra las pantallas post-pago de NIT, correo y teléfono. Envía `false` para omitirlas y volver a Modo espera, salvo cuando un NIT válido sea obligatorio.
- `print_receipt` (boolean, optional, default: false) — Imprime automáticamente el comprobante de pago después de un cobro exitoso. El resultado de impresión no cambia el estado financiero del pago.
- `tax_id` (string, optional) — (Opcional) NIT del comprador, cuando tu sistema ya lo tiene. La terminal se salta la pantalla del NIT y va directo a la de comprobantes: Recurrente emite la factura con este NIT y el comprobante lo lleva impreso. Un NIT inválido se ignora y la pantalla se muestra igual para que el cajero lo corrija.
- `application_fee_amount` (integer, optional) — (Opcional) Comisión de plataforma en centavos. Requiere que el cobro sea a nombre de una cuenta conectada (modelo directo): cuando el cobro se completa, Recurrente transfiere este monto del balance de la cuenta conectada al de tu plataforma. La comisión se puede revertir al reembolsar con `refund_application_fee: true`, y se incluye en la facturación diaria de comisiones (DTE) si la conexión la tiene habilitada. No se puede combinar con un `transfer_setups` de `purpose: platform_commission`.
- `transfer_setups` (list of TerminalSessionCommandsPostRequestBodyContentApplicationJsonSchemaTransferSetupsItems, optional) — (Opcional) Transferencias para enrutar fondos a una cuenta conectada tras un cobro exitoso (modelo destino). El destinatario debe ser tu cuenta o una cuenta conectada. Para cobrar una comisión de plataforma usa `application_fee_amount` en su lugar.

## Response

### 201

Comando creado exitosamente

- `id` (string, optional) — ID público aleatorio del comando
- `external_id` (string, optional) — ID único de tu sistema dentro de la cuenta autenticada
- `status` (enum, optional) — Estado del comando
  - Allowed values: `pending`, `dispatched`, `cancel_requested`, `canceled`, `superseded`, `consumed`, `failed`
- `final` (boolean, optional) — `true` cuando el comando alcanzó un resultado definitivo y ya no puede cambiar
- `terminal_id` (string, optional) — ID de la terminal POS
- `amount_in_cents` (integer, optional) — Monto en centavos. Para un cobro con `items`, la suma de los items.
- `currency` (enum, optional) — Moneda del cobro
  - Allowed values: `GTQ`, `USD`
- `installments` (integer, optional, nullable) — Meses sin intereses solicitados, o `null` si el cobro va sin cuotas
- `description` (string, optional, nullable) — Concepto del cobro enviado al crear el comando, o `null` si no se envió uno
- `show_post_payment_screens` (boolean, optional) — Indica si el comando solicita mostrar las pantallas post-pago de NIT, correo y teléfono
- `print_receipt` (boolean, optional) — Indica si el comando solicita imprimir automáticamente el comprobante de pago
- `tax_id` (string, optional, nullable) — NIT del comprador enviado con el cobro, o `null` si no se envió uno
- `terminal_availability` (enum, optional) — Disponibilidad observada de la terminal para recibir comandos
  - Allowed values: `available`, `unavailable`
- `checkout_id` (string, optional) — ID del checkout generado
- `checkout_url` (string, optional) — URL del checkout (la terminal usa esta URL internamente)
- `checkout_status` (enum, optional) — Estado actual del checkout asociado
  - Allowed values: `unpaid`, `paid`, `failed`, `payment_in_progress`, `needs_verification`, `no_payment_required`, `verification_failed`, `needs_payer_authentication`
- `cancellation_requested_at` (datetime, optional, nullable) — Momento en que se solicitó detener un comando ya despachado
- `canceled_at` (datetime, optional, nullable) — Momento en que la cancelación se volvió definitiva

## Errors

### 403 Forbidden Error

Se requiere una llave LIVE para una terminal física

- `message` (string, optional) — Mensaje de error
- `code` (string, optional) — Código estable legible por máquinas, cuando aplica
- `refund_id` (string, optional) — ID del reembolso relacionado cuando aplica
- `endpoint` (string, optional) — Acción de API rechazada, cuando aplica
- `errors` (ErrorErrors, optional) — Detalles de errores por campo

### 404 Not Found Error

No encontramos la terminal o la cuenta conectada

- `message` (string, optional) — Mensaje de error
- `code` (string, optional) — Código estable legible por máquinas, cuando aplica
- `refund_id` (string, optional) — ID del reembolso relacionado cuando aplica
- `endpoint` (string, optional) — Acción de API rechazada, cuando aplica
- `errors` (ErrorErrors, optional) — Detalles de errores por campo

### 409 Conflict Error

La terminal no está disponible para recibir comandos

- `message` (string, optional) — Mensaje de error
- `code` (string, optional) — Código estable legible por máquinas, cuando aplica
- `refund_id` (string, optional) — ID del reembolso relacionado cuando aplica
- `endpoint` (string, optional) — Acción de API rechazada, cuando aplica
- `errors` (ErrorErrors, optional) — Detalles de errores por campo

### 422 Unprocessable Entity Error

Error de validación

- `message` (string, optional) — Mensaje de error
- `code` (string, optional) — Código estable legible por máquinas, cuando aplica
- `refund_id` (string, optional) — ID del reembolso relacionado cuando aplica
- `endpoint` (string, optional) — Acción de API rechazada, cuando aplica
- `errors` (ErrorErrors, optional) — Detalles de errores por campo

## Types

### TerminalSessionCommandsPostRequestBodyContentApplicationJsonSchemaItemsItems

- `price_id` (string, optional) — ID del precio a cobrar (`pri_...`). Envía `price_id` o `product_id` en cada item.
- `product_id` (string, optional) — ID del producto (`prod_...`); se cobra su precio vigente. Alternativa a `price_id`.
- `quantity` (integer, optional, default: 1) — Unidades de este item

### TerminalSessionCommandsPostRequestBodyContentApplicationJsonSchemaTransferSetupsItems

- `amount_in_cents` (integer, optional) — Monto en centavos a transferir. No puede exceder el monto neto disponible después de fees, FEL e IVA.
- `recipient_id` (string, optional) — ID de la cuenta destinataria (tu cuenta o una cuenta conectada). Si se omite, se usa tu cuenta.
- `purpose` (enum, optional, default: fund_split) — Legacy — omítelo. `fund_split` (el valor predeterminado) es una distribución ordinaria de fondos. `platform_commission` marca la transferencia como comisión de plataforma; para eso usa `application_fee_amount`, que crea la misma transferencia sin que tengas que armarla a mano. Se sigue aceptando por compatibilidad y no se puede combinar con ese parámetro.
  - Allowed values: `fund_split`, `platform_commission`

### ErrorErrors

Detalles de errores por campo

## Examples

### Monto en centavos

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 5000
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Monto en centavos
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "amount_in_cents": 5000
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Monto en centavos
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","amount_in_cents":5000}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Monto en centavos
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Monto en centavos
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000\n}"

response = http.request(request)
puts response.read_body
```

```java Monto en centavos
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000\n}")
  .asString();
```

```php Monto en centavos
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 5000
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Monto en centavos
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Monto en centavos
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 5000
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Monto en unidades

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount": 50
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Monto en unidades
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "amount": 50
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Monto en unidades
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","amount":50}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Monto en unidades
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount\": 50\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Monto en unidades
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount\": 50\n}"

response = http.request(request)
puts response.read_body
```

```java Monto en unidades
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount\": 50\n}")
  .asString();
```

```php Monto en unidades
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount": 50
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Monto en unidades
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount\": 50\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Monto en unidades
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount": 50
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobro con concepto visible para el cliente

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 5000,
  "description": "Orden #1234"
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Cobro con concepto visible para el cliente
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "amount_in_cents": 5000,
    "description": "Orden #1234"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobro con concepto visible para el cliente
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","amount_in_cents":5000,"description":"Orden #1234"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobro con concepto visible para el cliente
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000,\n  \"description\": \"Orden #1234\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobro con concepto visible para el cliente
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000,\n  \"description\": \"Orden #1234\"\n}"

response = http.request(request)
puts response.read_body
```

```java Cobro con concepto visible para el cliente
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000,\n  \"description\": \"Orden #1234\"\n}")
  .asString();
```

```php Cobro con concepto visible para el cliente
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 5000,
  "description": "Orden #1234"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobro con concepto visible para el cliente
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 5000,\n  \"description\": \"Orden #1234\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobro con concepto visible para el cliente
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 5000,
  "description": "Orden #1234"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobro de productos existentes (el total se calcula de los items)

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "items": [
    {
      "price_id": "pri_abc123",
      "quantity": 2
    },
    {
      "product_id": "prod_xyz789"
    }
  ]
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Cobro de productos existentes (el total se calcula de los items)
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "items": [{
            "price_id": "pri_abc123",
            "quantity": 2
        }, { "product_id": "prod_xyz789" }]
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobro de productos existentes (el total se calcula de los items)
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","items":[{"price_id":"pri_abc123","quantity":2},{"product_id":"prod_xyz789"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobro de productos existentes (el total se calcula de los items)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"items\": [\n    {\n      \"price_id\": \"pri_abc123\",\n      \"quantity\": 2\n    },\n    {\n      \"product_id\": \"prod_xyz789\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobro de productos existentes (el total se calcula de los items)
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"items\": [\n    {\n      \"price_id\": \"pri_abc123\",\n      \"quantity\": 2\n    },\n    {\n      \"product_id\": \"prod_xyz789\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java Cobro de productos existentes (el total se calcula de los items)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"items\": [\n    {\n      \"price_id\": \"pri_abc123\",\n      \"quantity\": 2\n    },\n    {\n      \"product_id\": \"prod_xyz789\"\n    }\n  ]\n}")
  .asString();
```

```php Cobro de productos existentes (el total se calcula de los items)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "items": [
    {
      "price_id": "pri_abc123",
      "quantity": 2
    },
    {
      "product_id": "prod_xyz789"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobro de productos existentes (el total se calcula de los items)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"items\": [\n    {\n      \"price_id\": \"pri_abc123\",\n      \"quantity\": 2\n    },\n    {\n      \"product_id\": \"prod_xyz789\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobro de productos existentes (el total se calcula de los items)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "items": [[
      "price_id": "pri_abc123",
      "quantity": 2
    ], ["product_id": "prod_xyz789"]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobro en cuotas (6 meses sin intereses)

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 120000,
  "installments": 6
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Cobro en cuotas (6 meses sin intereses)
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "amount_in_cents": 120000,
    "installments": 6
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobro en cuotas (6 meses sin intereses)
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","amount_in_cents":120000,"installments":6}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobro en cuotas (6 meses sin intereses)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 120000,\n  \"installments\": 6\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobro en cuotas (6 meses sin intereses)
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 120000,\n  \"installments\": 6\n}"

response = http.request(request)
puts response.read_body
```

```java Cobro en cuotas (6 meses sin intereses)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 120000,\n  \"installments\": 6\n}")
  .asString();
```

```php Cobro en cuotas (6 meses sin intereses)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 120000,
  "installments": 6
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobro en cuotas (6 meses sin intereses)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 120000,\n  \"installments\": 6\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobro en cuotas (6 meses sin intereses)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 120000,
  "installments": 6
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobro de kiosco sin captura post-pago

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "kiosk-order-1234",
  "amount_in_cents": 5000,
  "show_post_payment_screens": false,
  "print_receipt": true
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Cobro de kiosco sin captura post-pago
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "kiosk-order-1234",
    "amount_in_cents": 5000,
    "show_post_payment_screens": False,
    "print_receipt": True
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobro de kiosco sin captura post-pago
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"kiosk-order-1234","amount_in_cents":5000,"show_post_payment_screens":false,"print_receipt":true}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobro de kiosco sin captura post-pago
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"kiosk-order-1234\",\n  \"amount_in_cents\": 5000,\n  \"show_post_payment_screens\": false,\n  \"print_receipt\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobro de kiosco sin captura post-pago
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"kiosk-order-1234\",\n  \"amount_in_cents\": 5000,\n  \"show_post_payment_screens\": false,\n  \"print_receipt\": true\n}"

response = http.request(request)
puts response.read_body
```

```java Cobro de kiosco sin captura post-pago
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"kiosk-order-1234\",\n  \"amount_in_cents\": 5000,\n  \"show_post_payment_screens\": false,\n  \"print_receipt\": true\n}")
  .asString();
```

```php Cobro de kiosco sin captura post-pago
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "kiosk-order-1234",
  "amount_in_cents": 5000,
  "show_post_payment_screens": false,
  "print_receipt": true
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobro de kiosco sin captura post-pago
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"kiosk-order-1234\",\n  \"amount_in_cents\": 5000,\n  \"show_post_payment_screens\": false,\n  \"print_receipt\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobro de kiosco sin captura post-pago
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "kiosk-order-1234",
  "amount_in_cents": 5000,
  "show_post_payment_screens": false,
  "print_receipt": true
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobro a nombre de una cuenta conectada (modelo directo, solo epay)

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 50000,
  "application_fee_amount": 5000
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "amount_in_cents": 50000,
    "application_fee_amount": 5000
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","amount_in_cents":50000,"application_fee_amount":5000}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"application_fee_amount\": 5000\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"application_fee_amount\": 5000\n}"

response = http.request(request)
puts response.read_body
```

```java Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"application_fee_amount\": 5000\n}")
  .asString();
```

```php Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 50000,
  "application_fee_amount": 5000
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"application_fee_amount\": 5000\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobro a nombre de una cuenta conectada (modelo directo, solo epay)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 50000,
  "application_fee_amount": 5000
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)

**Request**

```json
{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 50000,
  "transfer_setups": [
    {
      "amount_in_cents": 45000,
      "recipient_id": "ac_123456"
    }
  ]
}
```

**Response**

```json
{
  "id": "tsc_abc123",
  "external_id": "order-1234",
  "status": "pending",
  "final": false,
  "terminal_id": "trm_abc123",
  "amount_in_cents": 5000,
  "currency": "GTQ",
  "description": null,
  "show_post_payment_screens": true,
  "print_receipt": false,
  "tax_id": null,
  "terminal_availability": "available",
  "checkout_id": "ch_xyz789",
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_xyz789",
  "checkout_status": "unpaid",
  "cancellation_requested_at": null,
  "canceled_at": null
}
```

**SDK Code**

```python Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
import requests

url = "https://app.recurrente.com/api/terminal_session_commands"

payload = {
    "terminal_id": "trm_abc123",
    "currency": "GTQ",
    "external_id": "order-1234",
    "amount_in_cents": 50000,
    "transfer_setups": [
        {
            "amount_in_cents": 45000,
            "recipient_id": "ac_123456"
        }
    ]
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
const url = 'https://app.recurrente.com/api/terminal_session_commands';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"terminal_id":"trm_abc123","currency":"GTQ","external_id":"order-1234","amount_in_cents":50000,"transfer_setups":[{"amount_in_cents":45000,"recipient_id":"ac_123456"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/terminal_session_commands"

	payload := strings.NewReader("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/terminal_session_commands")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/terminal_session_commands")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}")
  .asString();
```

```php Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/terminal_session_commands', [
  'body' => '{
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 50000,
  "transfer_setups": [
    {
      "amount_in_cents": 45000,
      "recipient_id": "ac_123456"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/terminal_session_commands");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"terminal_id\": \"trm_abc123\",\n  \"currency\": \"GTQ\",\n  \"external_id\": \"order-1234\",\n  \"amount_in_cents\": 50000,\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobro propio con fondos enrutados a una cuenta conectada (modelo destino)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "terminal_id": "trm_abc123",
  "currency": "GTQ",
  "external_id": "order-1234",
  "amount_in_cents": 50000,
  "transfer_setups": [
    [
      "amount_in_cents": 45000,
      "recipient_id": "ac_123456"
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/terminal_session_commands")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```