> 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 una transferencia

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

Mueve dinero desde tu balance al `destination` que indiques. En la mayoría de los casos basta pasar **el identificador como string** — el formato indica a dónde va el dinero:

| `destination`    | A dónde va                                                                           | Registro creado   |
| ---------------- | ------------------------------------------------------------------------------------ | ----------------- |
| `"ba_..."`       | Retiro a tu cuenta bancaria                                                          | `wi_` (asíncrono) |
| `"ac_..."`       | Transferencia a esa cuenta de Recurrente, sujeta a evaluación automática             | `tr_`             |
| `"@handle"`      | Transferencia a la cuenta con ese handle                                             | `tr_`             |
| `"co_..."`       | Transferencia al teléfono de ese contacto guardado                                   | `tr_`             |
| `"+50255667788"` | Envío a un teléfono; tras aprobarse, queda `unclaimed` hasta que lo reclamen con KYC | `tr_`             |

P2P transfers are asynchronous. A successful response can be `pending` (automatic evaluation) or `in_review` (human review). Funds remain reserved until approval. Rejection returns them to the sender's balance and changes the status to `cancelled`. Poll `GET /api/transfers/{id}` or subscribe to transfer webhooks. Cancellation is only available while `unclaimed`; a successful POST does not mean the recipient has received the money.

Para stablecoin (requiere verificación de stablecoin) o para ser explícito, usa la forma de objeto: `destination: {type: "crypto_address", address: "0x…", chain: "base", currency: "USDC"}` crea un envío `sw_`.

Requiere una llave con movimiento de dinero habilitado y la cuenta verificada. Usa `X-ACCOUNT-ID` para operar sobre una cuenta conectada (hija) verificada — admite destinos `bank_account`, y destinos `account` dentro de su misma plataforma (la cuenta madre o cuentas hermanas), para comisiones y liquidaciones.

Reference: https://docs.recurrente.com/referencia-api/api-reference/transfers/create-transfer

## 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

### Headers

- `Idempotency-Key` (string, optional) — Clave de idempotencia para reintentos seguros de operaciones críticas, especialmente las que mueven dinero o cambian estado operativo. Reintentar con la misma clave y el mismo cuerpo devuelve la respuesta original (header `Idempotency-Replayed: true`); reusarla con parámetros distintos devuelve 409.

### Body (application/json)

This endpoint expects an object.

- `amount_in_cents` (integer, required) — Monto en centavos que se debita del balance en `currency`
- `destination` (TransfersPostRequestBodyContentApplicationJsonSchemaDestination, required) — A dónde va el dinero — el identificador como string (`ba_`/`ac_`/`co_` id, `@handle` o teléfono), o el objeto tipado para stablecoin y casos avanzados
- `currency` (enum, optional) — Moneda del balance de origen. Para destinos `bank_account` es opcional (por defecto, la moneda de la cuenta bancaria); requerida para los demás destinos.
  - Allowed values: `GTQ`, `USD`
- `note` (string, optional) — (Opcional) Nota o descripción del movimiento. En retiros bancarios, el beneficiario la ve como concepto en su página de seguimiento.
- `recipient_email` (string, optional) — Solo destinos `bank_account` — correo del beneficiario. Le enviamos la fecha estimada de llegada y el link de seguimiento, y le avisamos cuando el retiro sale hacia su banco o no se completa.
- `is_instant` (boolean, optional) — Solo destinos `bank_account` — retiro instantáneo (sujeto a elegibilidad y comisión)
- `should_perform_currency_conversion` (boolean, optional) — Solo destinos `bank_account` — convierte el balance a la moneda de la cuenta bancaria destino

## Response

### 201

Movimiento creado. Los retiros (`wi_`) y envíos cripto (`sw_`) son asíncronos — la respuesta trae el estado inicial; consulta el estado o suscríbete a los webhooks.

- `id` (string, optional) — ID del movimiento (tr_ / wi_ / sw_)
- `status` (enum, optional) — Estado canónico del movimiento
  - Allowed values: `pending`, `in_review`, `processing`, `sent`, `unclaimed`, `completed`, `failed`, `cancelled`
- `status_detail` (string, optional) — Estado crudo del registro subyacente (p. ej. `approved`, `rejected`, `review_requested`)
- `amount_in_cents` (integer, optional) — Monto en centavos debitado del balance
- `currency` (string, optional) — Moneda del balance de origen
- `fee_in_cents` (integer, optional) — Comisión en centavos (retiros instantáneos / internacionales; 0 para p2p)
- `net_amount_in_cents` (integer, optional) — Monto neto que llega al destino después de comisiones
- `note` (string, optional, nullable) — Nota del movimiento
- `recipient_email` (string, optional, nullable) — Correo del beneficiario al que le avisamos el estado del retiro. Solo aplica a movimientos `wi_`.
- `tracking_url` (string, optional, nullable) — Página pública de seguimiento para el beneficiario (monto que recibe, cuenta enmascarada, estado y fecha estimada de llegada). Solo aplica a movimientos `wi_`; compártela con quien recibe el dinero.
- `account_id` (string, optional) — Cuenta cuyo balance movió este envío. Siempre presente, para que una lista que abarca varias cuentas de una organización siga siendo atribuible.
- `sent_at` (datetime, optional, nullable) — Momento en que Recurrente envió el retiro al banco; solo aplica a retiros bancarios (`wi_`).
- `settled_at` (datetime, optional, nullable) — Momento de liquidación bancaria confirmada. Solo está presente para retiros bancarios confirmados o completados (`wi_`).
- `bank_reference` (string, optional, nullable) — Referencia que devolvió el riel de envío, cuando ese riel devuelve una. Solo aplica a movimientos `wi_`; no identifica ni enumera transacciones que conformen el retiro.
- `bank_reference_status` (enum, optional, nullable) — Qué esperar de `bank_reference`: `available` si ya existe, `pending` si el retiro aún no sale y podría traerla, y `unsupported` si ya salió por un riel que nunca devuelve una. Con `unsupported`, concilia el depósito por `statement_descriptor`.
  - Allowed values: `available`, `pending`, `unsupported`
- `statement_descriptor` (string, optional, nullable) — Lo que le pedimos al banco que imprima en el estado de cuenta del beneficiario. Solo aplica a movimientos `wi_`.
- `balance_transaction_id` (string, optional, nullable) — Fila del ledger que registró este movimiento (`GET /api/balance_transactions/{id}`). Vacío mientras el dinero no haya salido del balance.
- `destination` (TransferDestination, optional) — Destino del movimiento. Los campos presentes dependen de `type`.
- `created_at` (datetime, optional) — Fecha de creación
- `sender` (TransferSender, optional) — (Solo registros tr_) Cuenta emisora — campo legado
- `recipient` (TransferRecipient, optional) — (Solo registros tr_) Destinatario — campo legado
- `reversal_of_id` (string, optional) — ID del transfer original; solo aparece en reversos por reembolso
- `refund_id` (string, optional) — ID del reembolso que originó el reverso

## Errors

### 400 Bad Request Error

Error de validación (fondos insuficientes, destinatario inexistente o cuenta bancaria malformada)

- `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

### 403 Forbidden Error

Llave sin movimiento de dinero (money_movement_not_enabled), cuenta no activa (account_not_active), verificación pendiente (verification_required), verificación de stablecoin pendiente (stablecoin_verification_required) o cuenta conectada sin verificar (connected_account_unverified)

- `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

El destino es inválido (invalid_destination), falta moneda (currency_required), falta destinatario (recipient_required), el destino no está soportado para cuentas conectadas (destination_not_supported), o el destinatario es ambiguo (ambiguous_recipient)

- `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

### TransfersPostRequestBodyContentApplicationJsonSchemaDestination

A dónde va el dinero — el identificador como string (`ba_`/`ac_`/`co_` id, `@handle` o teléfono), o el objeto tipado para stablecoin y casos avanzados

### TransferDestination

Destino del movimiento. Los campos presentes dependen de `type`.

- `type` (enum, optional)
  - Allowed values: `bank_account`, `account`, `phone_number`, `crypto_address`
- `id` (string, optional, nullable) — ID del recurso destino (`ba_` cuenta bancaria, `ac_` cuenta, `cr_` dirección cripto)
- `bank_name` (string, optional) — bank_account: banco destino
- `holder_name` (string, optional) — bank_account: titular de la cuenta bancaria
- `currency` (string, optional) — bank_account: moneda de la cuenta bancaria. crypto_address: stablecoin enviada
- `name` (string, optional) — account: nombre de la cuenta destinataria
- `number` (string, optional) — phone_number: teléfono del destinatario
- `address` (string, optional) — crypto_address: dirección on-chain
- `chain` (string, optional) — crypto_address: red del envío
- `amount` (integer, optional) — crypto_address: monto en unidades menores de la stablecoin que llega al destino

### TransferSender

(Solo registros tr_) Cuenta emisora — campo legado

- `id` (string, optional)
- `name` (string, optional)
- `type` (string, optional)

### TransferRecipient

(Solo registros tr_) Destinatario — campo legado

- `id` (string, optional, nullable)
- `name` (string, optional)
- `type` (string, optional)

### ErrorErrors

Detalles de errores por campo

### TransferDestinationRequest

Destino tipado del movimiento. Los campos aplicables dependen de `type`.

- `type` (enum, required)
  - Allowed values: `bank_account`, `account`, `phone_number`, `crypto_address`
- `id` (string, optional) — bank_account: ID de tu cuenta bancaria (ba_). account: ID (ac_) o handle (@) de la cuenta destinataria. crypto_address: ID de una dirección guardada (cr_).
- `number` (string, optional) — phone_number: teléfono del destinatario
- `contact_id` (string, optional) — phone_number: ID de un contacto guardado (co_), alternativo a number
- `address` (string, optional) — crypto_address: dirección on-chain, alternativa a id
- `chain` (string, optional) — crypto_address: red (base, ethereum, polygon, solana, stellar, tron…)
- `currency` (string, optional) — crypto_address: stablecoin a enviar (USDC, USDT…)
- `blockchain_memo` (string, optional) — crypto_address: memo on-chain (requerido en stellar)

## Examples

### Retiro instantáneo

**Request**

```json
{
  "amount_in_cents": 50000,
  "destination": "ba_abc123",
  "is_instant": true
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Retiro instantáneo
import requests

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

payload = {
    "amount_in_cents": 50000,
    "destination": "ba_abc123",
    "is_instant": True
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Retiro instantáneo
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":50000,"destination":"ba_abc123","is_instant":true}'
};

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

```go Retiro instantáneo
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"is_instant\": 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 Retiro instantáneo
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"is_instant\": true\n}"

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

```java Retiro instantáneo
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"is_instant\": true\n}")
  .asString();
```

```php Retiro instantáneo
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 50000,
  "destination": "ba_abc123",
  "is_instant": true
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Retiro instantáneo
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/transfers");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"is_instant\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Retiro instantáneo
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 50000,
  "destination": "ba_abc123",
  "is_instant": true
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Retiro a un tercero, avisándole por correo

**Request**

```json
{
  "amount_in_cents": 50000,
  "destination": "ba_abc123",
  "note": "Factura 123",
  "recipient_email": "maria@example.com"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Retiro a un tercero, avisándole por correo
import requests

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

payload = {
    "amount_in_cents": 50000,
    "destination": "ba_abc123",
    "note": "Factura 123",
    "recipient_email": "maria@example.com"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Retiro a un tercero, avisándole por correo
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":50000,"destination":"ba_abc123","note":"Factura 123","recipient_email":"maria@example.com"}'
};

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

```go Retiro a un tercero, avisándole por correo
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"note\": \"Factura 123\",\n  \"recipient_email\": \"maria@example.com\"\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 Retiro a un tercero, avisándole por correo
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"note\": \"Factura 123\",\n  \"recipient_email\": \"maria@example.com\"\n}"

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

```java Retiro a un tercero, avisándole por correo
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"note\": \"Factura 123\",\n  \"recipient_email\": \"maria@example.com\"\n}")
  .asString();
```

```php Retiro a un tercero, avisándole por correo
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 50000,
  "destination": "ba_abc123",
  "note": "Factura 123",
  "recipient_email": "maria@example.com"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Retiro a un tercero, avisándole por correo
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/transfers");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\",\n  \"note\": \"Factura 123\",\n  \"recipient_email\": \"maria@example.com\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Retiro a un tercero, avisándole por correo
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 50000,
  "destination": "ba_abc123",
  "note": "Factura 123",
  "recipient_email": "maria@example.com"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Transferencia a otra cuenta

**Request**

```json
{
  "amount_in_cents": 10000,
  "destination": "ac_xyz789",
  "currency": "GTQ",
  "note": "Pago de servicios"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Transferencia a otra cuenta
import requests

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

payload = {
    "amount_in_cents": 10000,
    "destination": "ac_xyz789",
    "currency": "GTQ",
    "note": "Pago de servicios"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Transferencia a otra cuenta
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":10000,"destination":"ac_xyz789","currency":"GTQ","note":"Pago de servicios"}'
};

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

```go Transferencia a otra cuenta
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 10000,\n  \"destination\": \"ac_xyz789\",\n  \"currency\": \"GTQ\",\n  \"note\": \"Pago de servicios\"\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 Transferencia a otra cuenta
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 10000,\n  \"destination\": \"ac_xyz789\",\n  \"currency\": \"GTQ\",\n  \"note\": \"Pago de servicios\"\n}"

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

```java Transferencia a otra cuenta
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 10000,\n  \"destination\": \"ac_xyz789\",\n  \"currency\": \"GTQ\",\n  \"note\": \"Pago de servicios\"\n}")
  .asString();
```

```php Transferencia a otra cuenta
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 10000,
  "destination": "ac_xyz789",
  "currency": "GTQ",
  "note": "Pago de servicios"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Transferencia a otra cuenta
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/transfers");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount_in_cents\": 10000,\n  \"destination\": \"ac_xyz789\",\n  \"currency\": \"GTQ\",\n  \"note\": \"Pago de servicios\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Transferencia a otra cuenta
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 10000,
  "destination": "ac_xyz789",
  "currency": "GTQ",
  "note": "Pago de servicios"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Transferencia por handle

**Request**

```json
{
  "amount_in_cents": 10000,
  "destination": "@mitienda",
  "currency": "GTQ"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Transferencia por handle
import requests

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

payload = {
    "amount_in_cents": 10000,
    "destination": "@mitienda",
    "currency": "GTQ"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Transferencia por handle
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":10000,"destination":"@mitienda","currency":"GTQ"}'
};

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

```go Transferencia por handle
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 10000,\n  \"destination\": \"@mitienda\",\n  \"currency\": \"GTQ\"\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 Transferencia por handle
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 10000,\n  \"destination\": \"@mitienda\",\n  \"currency\": \"GTQ\"\n}"

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

```java Transferencia por handle
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 10000,\n  \"destination\": \"@mitienda\",\n  \"currency\": \"GTQ\"\n}")
  .asString();
```

```php Transferencia por handle
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 10000,
  "destination": "@mitienda",
  "currency": "GTQ"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Transferencia por handle
using RestSharp;

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

```swift Transferencia por handle
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 10000,
  "destination": "@mitienda",
  "currency": "GTQ"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Envío a un teléfono

**Request**

```json
{
  "amount_in_cents": 5000,
  "destination": "+50255667788",
  "currency": "GTQ"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Envío a un teléfono
import requests

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

payload = {
    "amount_in_cents": 5000,
    "destination": "+50255667788",
    "currency": "GTQ"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Envío a un teléfono
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":5000,"destination":"+50255667788","currency":"GTQ"}'
};

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

```go Envío a un teléfono
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 5000,\n  \"destination\": \"+50255667788\",\n  \"currency\": \"GTQ\"\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 Envío a un teléfono
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 5000,\n  \"destination\": \"+50255667788\",\n  \"currency\": \"GTQ\"\n}"

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

```java Envío a un teléfono
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```php Envío a un teléfono
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp Envío a un teléfono
using RestSharp;

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

```swift Envío a un teléfono
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 5000,
  "destination": "+50255667788",
  "currency": "GTQ"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Envío a un contacto guardado

**Request**

```json
{
  "amount_in_cents": 5000,
  "destination": "co_maria123",
  "currency": "GTQ"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Envío a un contacto guardado
import requests

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

payload = {
    "amount_in_cents": 5000,
    "destination": "co_maria123",
    "currency": "GTQ"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Envío a un contacto guardado
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":5000,"destination":"co_maria123","currency":"GTQ"}'
};

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

```go Envío a un contacto guardado
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 5000,\n  \"destination\": \"co_maria123\",\n  \"currency\": \"GTQ\"\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 Envío a un contacto guardado
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 5000,\n  \"destination\": \"co_maria123\",\n  \"currency\": \"GTQ\"\n}"

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

```java Envío a un contacto guardado
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```php Envío a un contacto guardado
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp Envío a un contacto guardado
using RestSharp;

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

```swift Envío a un contacto guardado
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Envío de stablecoin (forma de objeto)

**Request**

```json
{
  "amount_in_cents": 10000,
  "destination": {
    "type": "crypto_address",
    "address": "0x71C7656EC7ab88b098defB751B7401B5f6d8976F",
    "chain": "base",
    "currency": "USDC"
  },
  "currency": "USD"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Envío de stablecoin (forma de objeto)
import requests

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

payload = {
    "amount_in_cents": 10000,
    "destination": {
        "type": "crypto_address",
        "address": "0x71C7656EC7ab88b098defB751B7401B5f6d8976F",
        "chain": "base",
        "currency": "USDC"
    },
    "currency": "USD"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Envío de stablecoin (forma de objeto)
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":10000,"destination":{"type":"crypto_address","address":"0x71C7656EC7ab88b098defB751B7401B5f6d8976F","chain":"base","currency":"USDC"},"currency":"USD"}'
};

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

```go Envío de stablecoin (forma de objeto)
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 10000,\n  \"destination\": {\n    \"type\": \"crypto_address\",\n    \"address\": \"0x71C7656EC7ab88b098defB751B7401B5f6d8976F\",\n    \"chain\": \"base\",\n    \"currency\": \"USDC\"\n  },\n  \"currency\": \"USD\"\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 Envío de stablecoin (forma de objeto)
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 10000,\n  \"destination\": {\n    \"type\": \"crypto_address\",\n    \"address\": \"0x71C7656EC7ab88b098defB751B7401B5f6d8976F\",\n    \"chain\": \"base\",\n    \"currency\": \"USDC\"\n  },\n  \"currency\": \"USD\"\n}"

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

```java Envío de stablecoin (forma de objeto)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 10000,\n  \"destination\": {\n    \"type\": \"crypto_address\",\n    \"address\": \"0x71C7656EC7ab88b098defB751B7401B5f6d8976F\",\n    \"chain\": \"base\",\n    \"currency\": \"USDC\"\n  },\n  \"currency\": \"USD\"\n}")
  .asString();
```

```php Envío de stablecoin (forma de objeto)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 10000,
  "destination": {
    "type": "crypto_address",
    "address": "0x71C7656EC7ab88b098defB751B7401B5f6d8976F",
    "chain": "base",
    "currency": "USDC"
  },
  "currency": "USD"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Envío de stablecoin (forma de objeto)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/transfers");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount_in_cents\": 10000,\n  \"destination\": {\n    \"type\": \"crypto_address\",\n    \"address\": \"0x71C7656EC7ab88b098defB751B7401B5f6d8976F\",\n    \"chain\": \"base\",\n    \"currency\": \"USDC\"\n  },\n  \"currency\": \"USD\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Envío de stablecoin (forma de objeto)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 10000,
  "destination": [
    "type": "crypto_address",
    "address": "0x71C7656EC7ab88b098defB751B7401B5f6d8976F",
    "chain": "base",
    "currency": "USDC"
  ],
  "currency": "USD"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Retiro para una cuenta conectada (hija)

**Request**

```json
{
  "amount_in_cents": 50000,
  "destination": "ba_delahija"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python Retiro para una cuenta conectada (hija)
import requests

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

payload = {
    "amount_in_cents": 50000,
    "destination": "ba_delahija"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Retiro para una cuenta conectada (hija)
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":50000,"destination":"ba_delahija"}'
};

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

```go Retiro para una cuenta conectada (hija)
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_delahija\"\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 Retiro para una cuenta conectada (hija)
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_delahija\"\n}"

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

```java Retiro para una cuenta conectada (hija)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_delahija\"\n}")
  .asString();
```

```php Retiro para una cuenta conectada (hija)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 50000,
  "destination": "ba_delahija"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Retiro para una cuenta conectada (hija)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/transfers");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_delahija\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Retiro para una cuenta conectada (hija)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 50000,
  "destination": "ba_delahija"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```

### Example 9

**Request**

```json
{
  "amount_in_cents": 50000,
  "destination": "ba_abc123"
}
```

**Response**

```json
{
  "id": "tr_nr4yplup",
  "status": "completed",
  "status_detail": "completed",
  "amount_in_cents": 100,
  "currency": "GTQ",
  "fee_in_cents": 0,
  "net_amount_in_cents": 100,
  "note": "string",
  "recipient_email": "maria@example.com",
  "tracking_url": "https://app.recurrente.com/t/3xK9mPq2vLn8RtWz4Yb7Hc",
  "account_id": "ac_merchant1",
  "sent_at": "2024-01-15T09:30:00Z",
  "settled_at": "2024-01-15T09:30:00Z",
  "bank_reference": "REC-123-abcdef12",
  "bank_reference_status": "unsupported",
  "statement_descriptor": "wi_ab12cd34",
  "balance_transaction_id": "txn_ab12cd34",
  "destination": {
    "type": "bank_account",
    "id": "string",
    "bank_name": "string",
    "holder_name": "string",
    "currency": "string",
    "name": "string",
    "number": "string",
    "address": "string",
    "chain": "string",
    "amount": 1
  },
  "created_at": "2024-01-15T09:30:00Z",
  "sender": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "recipient": {
    "id": "string",
    "name": "string",
    "type": "account"
  },
  "reversal_of_id": "string",
  "refund_id": "string"
}
```

**SDK Code**

```python
import requests

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

payload = {
    "amount_in_cents": 50000,
    "destination": "ba_abc123"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://app.recurrente.com/api/transfers';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"amount_in_cents":50000,"destination":"ba_abc123"}'
};

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

```go
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\"\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
require 'uri'
require 'net/http'

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

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  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\"\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/transfers")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/transfers', [
  'body' => '{
  "amount_in_cents": 50000,
  "destination": "ba_abc123"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/transfers");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount_in_cents\": 50000,\n  \"destination\": \"ba_abc123\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "amount_in_cents": 50000,
  "destination": "ba_abc123"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/transfers")! 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()
```