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

# Actualizar una suscripción

PUT https://app.recurrente.com/api/subscriptions/{id}
Content-Type: application/json

Actualiza una suscripción. Puedes:

* **Cambiar el método de pago**: Envía `payment_method_id` con el ID de un método de pago activo del suscriptor. Si la suscripción tiene un pago pendiente, se intentará cobrar automáticamente con el nuevo método de pago.
* **Pausar**: Envía `act: "pause"`. Opcionalmente, incluye `resumes_on` para reactivación automática.
* **Reactivar**: Envía `act: "unpause"`.
* **Agregar o eliminar productos**: Envía un arreglo `items` con los cambios. Cada item identifica un precio con `price_id` o un producto con `product_id` (usa el primer precio del producto), y opcionalmente `quantity` (default `1`) o `deleted: true` para removerlo. Usa `mode` para decidir cuándo aplican: `"next_cycle"` (al siguiente cobro, default), `"now"` (inmediato; el prorrateo se suma al próximo cobro) o `"now_and_charge"` (inmediato y cobra el prorrateo al instante). En un Sandbox, una suscripción asociada a un Test Clock evalúa sus productos con la hora congelada de ese cliente. Para previsualizar el prorrateo antes de aplicar, usa [`POST /subscriptions/{id}/proration_preview`](#tag/Subscriptions/operation/previewSubscriptionProration).

Para un **cobro único o crédito** (una multa, un cargo puntual o un crédito de cortesía) tienes dos opciones: envía `add_invoice_items` en este mismo endpoint (se agregan como pendientes al próximo cobro, ideal para combinarlos con un cambio de productos en una sola llamada), o usa [`POST /one_time_payments`](#tag/One-Time-Payments/operation/createOneTimePayment) con `subscription_id` (que además permite cobrar de inmediato con `mode: now`). Un monto negativo es un crédito. Consulta o cancela los pendientes con `GET` y `DELETE /subscriptions/{subscription_id}/invoice_items`.

Reference: https://docs.recurrente.com/referencia-api/api-reference/subscriptions/update-subscription

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

### Path parameters

- `id` (string, required) — ID de la suscripción

### Body (application/json)

This endpoint expects a Subscriptions_updateSubscription_Request.

- `Subscriptions_updateSubscription_Request`

## Response

### 200

Suscripción actualizada

- `id` (string, optional) — ID único de la suscripción
- `description` (string, optional) — Descripción de la suscripción
- `status` (enum, optional) — Estado de la suscripción
  - Allowed values: `active`, `paused`, `past_due`, `cancelled`
- `created_at` (datetime, optional) — Fecha de creación
- `updated_at` (datetime, optional) — Última actualización
- `current_period_start` (datetime, optional, nullable) — Inicio del período de facturación actual
- `current_period_end` (datetime, optional, nullable) — Fin del período de facturación actual
- `tax_name` (string, optional, nullable) — Nombre fiscal del suscriptor
- `tax_id` (string, optional, nullable) — ID fiscal del suscriptor
- `resumes_on` (date, optional, nullable) — Fecha de reactivación automática (si está pausada)
- `next_payment_attempt_at` (datetime, optional, nullable) — Próximo intento de cobro automático (solo cuando el estado es `past_due`)
- `payment_retries` (integer, optional) — Número de reintentos de cobro realizados para el período actual. Recurrente intenta cobrar una vez al día por 15 días antes de cancelar la suscripción.
- `metadata` (Metadata, optional) — Metadata persistida durante todo el ciclo de vida de la suscripción y expuesta en sus webhooks.
- `test_clock_id` (string, optional, nullable) — ID del test clock heredado del Customer. Solo está presente en un Sandbox nombrado.
- `default_payment_method` (SubscriptionsIdPutResponsesContentApplicationJsonSchemaDefaultPaymentMethod, optional, nullable) — Método de pago predeterminado de la suscripción
- `subscriber` (Subscriber, optional)
- `checkout` (SubscriptionsIdPutResponsesContentApplicationJsonSchemaCheckout, optional, nullable)
- `product` (SubscriptionsIdPutResponsesContentApplicationJsonSchemaProduct, optional)
- `items` (list of SubscriptionItem, optional) — Lo que la suscripción cobra hoy y lo que un cambio con `next_cycle` dejó programado.
- `transfer_setups` (list of TransferSetup, optional) — Transferencias automáticas recurrentes de esta suscripción. En cada cobro exitoso, cada una transfiere su `amount_percent` del total de la factura a la cuenta destinataria.
- `application_fee_percent` (double, optional, nullable) — Comisión de plataforma como porcentaje del total de cada factura. `null` cuando la suscripción no paga comisión.
- `proration_charge` (SubscriptionsIdPutResponsesContentApplicationJsonSchemaProrationCharge, optional, nullable) — Presente solo con `mode: now_and_charge`: detalla el cobro inmediato del prorrateo. `null` en los demás modos.

## Errors

### 400 Bad Request Error

Acción inválida

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

Método de pago no encontrado

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

No se puede realizar la acción. Con `mode: now_and_charge` también ocurre cuando el cambio no genera un cobro inmediato (crédito o monto menor al mínimo — usa `now`), cuando la suscripción no tiene método de pago, o cuando el cobro del prorrateo es rechazado (en cuyo caso no se aplica ningún cambio).

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

### Cambiar método de pago

- `payment_method_id` (string, required) — ID del método de pago activo del suscriptor (ej. `pay_m_7v5ie3pw`)

### Pausar o reactivar

- `act` (enum, required) — Acción a realizar: `pause` para pausar, `unpause` para reactivar
  - Allowed values: `pause`, `unpause`
- `resumes_on` (date, optional) — (Opcional, solo para `pause`) Fecha en la que la suscripción se reactivará automáticamente (formato YYYY-MM-DD)

### Modificar productos o agregar cobros únicos

- `mode` (enum, optional) — Cuándo se aplican los cambios: - `next_cycle` (default): espera al siguiente cobro y no genera ajuste. - `now`: aplica inmediatamente y suma un prorrateo por los días que falten del ciclo actual al próximo invoice (cobro adicional al agregar, crédito al eliminar). - `now_and_charge`: aplica inmediatamente y cobra el prorrateo al instante al método de pago de la suscripción (equivalente a `always_invoice` de Stripe). Requiere un prorrateo neto positivo y mayor al mínimo de la moneda, y un método de pago; de lo contrario responde `422`. Si el cobro se rechaza, no se aplica ningún cambio. Para un cambio que resulte en crédito o en un monto menor al mínimo, usa `now`.
  - Allowed values: `next_cycle`, `now`, `now_and_charge`
- `items` (list of SubscriptionsIdPutRequestBodyContentApplicationJsonSchemaOneOf2ItemsItems, optional) — Lista de cambios. Cada item es un producto a agregar (default) o a eliminar (`deleted: true`).
- `add_invoice_items` (list of SubscriptionsIdPutRequestBodyContentApplicationJsonSchemaOneOf2AddInvoiceItemsItems, optional) — Cobros únicos (cargos o créditos) que se agregan como InvoiceItems pendientes al próximo cobro de la suscripción — equivalente a `add_invoice_items` de Stripe. Puedes enviarlos solos o junto con `items` (todo se aplica en una sola operación atómica). Un monto negativo es un crédito.

### Metadata

### SubscriptionsIdPutResponsesContentApplicationJsonSchemaDefaultPaymentMethod

Método de pago predeterminado de la suscripción

- `id` (string, optional) — ID del método de pago
- `type` (string, optional) — Tipo de método de pago
- `card` (SubscriptionsIdPutResponsesContentApplicationJsonSchemaDefaultPaymentMethodCard, optional, nullable)

### Subscriber

- `id` (string, optional) — ID del usuario suscriptor
- `first_name` (string, optional, nullable)
- `last_name` (string, optional, nullable)
- `full_name` (string, optional, nullable)
- `email` (string, optional)
- `phone_number` (string, optional, nullable)

### SubscriptionsIdPutResponsesContentApplicationJsonSchemaCheckout

- `id` (string, optional) — ID del checkout que originó la suscripción

### SubscriptionsIdPutResponsesContentApplicationJsonSchemaProduct

- `id` (string, optional) — ID del producto asociado

### SubscriptionItem

Una línea recurrente de la suscripción. Un cambio con `next_cycle` aparece como un ítem que empieza o termina en el futuro: `started_at` y `ended_at` dicen desde y hasta cuándo se cobra.

- `price_id` (string, optional)
- `product_id` (string, optional)
- `quantity` (integer, optional)
- `started_at` (datetime, optional, nullable) — `null` si se cobra desde el inicio de la suscripción.
- `ended_at` (datetime, optional, nullable) — `null` mientras siga cobrándose.

### TransferSetup

Transferencia automática de fondos a otra cuenta de Recurrente. Con `amount_in_cents` (pagos únicos) se ejecuta una vez al completarse el cobro; con `amount_percent` (suscripciones) se ejecuta en cada cobro exitoso, transfiriendo ese porcentaje del total de la factura.

- `id` (string, optional) — ID de la configuración de transferencia
- `status` (enum, optional) — En pagos únicos: `pending` mientras el cobro no se completa y `completed` cuando la transferencia se ejecutó. `in_review` indica que el monto está reservado por revisión de riesgo. Un reembolso del pago debe esperar a que se resuelva esa revisión. En suscripciones la configuración queda `pending` mientras la suscripción está activa. `cancelled` si la revisión rechazó el envío, o si el checkout, la suscripción o un reembolso canceló el setup antes de ejecutarlo; `reversed` si un reembolso devolvió una transferencia ya completada.
  - Allowed values: `pending`, `in_review`, `completed`, `cancelled`, `reversed`
- `amount_in_cents` (integer, optional, nullable) — Monto fijo en centavos a transferir (pagos únicos). No puede exceder el monto neto disponible después de fees, FEL e IVA.
- `amount_percent` (double, optional, nullable) — Porcentaje del total de cada factura a transferir (suscripciones).
- `currency` (string, optional) — Moneda
- `recipient_id` (string, optional) — ID de la cuenta de Recurrente que recibe los fondos (no es una cuenta bancaria).
- `purpose` (enum, optional, default: fund_split) — Qué representa la transferencia. `fund_split` (el valor predeterminado) es una distribución ordinaria de fondos: enruta parte del cobro a otra cuenta, sin más consecuencias. `platform_commission` marca la transferencia como la comisión que una cuenta conectada paga a su plataforma — es lo que crean `application_fee_amount` / `application_fee_percent` — y cambia tres comportamientos: solo puede fluir de la cuenta conectada hacia su plataforma (sobre una conexión activa), es la única que un reembolso revierte con `refund_application_fee: true`, y se incluye en la facturación diaria de comisiones (DTE) cuando la conexión la tiene habilitada.
  - Allowed values: `fund_split`, `platform_commission`

### SubscriptionsIdPutResponsesContentApplicationJsonSchemaProrationCharge

Presente solo con `mode: now_and_charge`: detalla el cobro inmediato del prorrateo. `null` en los demás modos.

- `intent_id` (string, optional) — Intent que cobró el prorrateo. Es el `id` del evento `intent.succeeded` de ese cobro y sirve para `GET /intents/{id}`, por ejemplo para leer `tax_invoice_url` si la FEL se emitió después.
- `amount_in_cents` (integer, optional)
- `currency` (string, optional)
- `status` (string, optional)

### ErrorErrors

Detalles de errores por campo

### SubscriptionsIdPutRequestBodyContentApplicationJsonSchemaOneOf2ItemsItems

- `price_id` (string, optional) — ID del precio recurrente (ej. `pr_abc123`). Acepta también `product_id`; si pasas ambos, `price_id` gana.
- `product_id` (string, optional) — ID del producto. Si lo usas, se utiliza el primer precio del producto. Útil cuando aún no conoces el `price_id`.
- `quantity` (integer, optional) — (Opcional) Cantidad para agregar. Default `1`. Ignorado cuando `deleted: true`.
- `deleted` (boolean, optional) — (Opcional) Si es `true`, elimina ese precio de la suscripción en lugar de agregarlo.

### SubscriptionsIdPutRequestBodyContentApplicationJsonSchemaOneOf2AddInvoiceItemsItems

- `amount_in_cents` (integer, required) — Monto en centavos, en la moneda de la suscripción. Negativo = crédito.
- `description` (string, required) — Descripción del cobro (ej. "Multa por mora").

### SubscriptionsIdPutResponsesContentApplicationJsonSchemaDefaultPaymentMethodCard

- `last4` (string, optional) — Últimos 4 dígitos de la tarjeta
- `network` (string, optional) — Red de la tarjeta

## Examples

### Método de pago actualizado

**Request**

```json
{
  "payment_method_id": "pay_m_7v5ie3pw"
}
```

**Response**

```json
{
  "id": "su_nehndm7j",
  "description": "One Free-Testable Banana",
  "status": "active",
  "default_payment_method": {
    "id": "pay_m_7v5ie3pw",
    "type": "card",
    "card": {
      "last4": "4242",
      "network": "visa"
    }
  }
}
```

**SDK Code**

```python Método de pago actualizado
import requests

url = "https://app.recurrente.com/api/subscriptions/id"

payload = { "payment_method_id": "pay_m_7v5ie3pw" }
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Método de pago actualizado
const url = 'https://app.recurrente.com/api/subscriptions/id';
const options = {
  method: 'PUT',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"payment_method_id":"pay_m_7v5ie3pw"}'
};

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

```go Método de pago actualizado
package main

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

func main() {

	url := "https://app.recurrente.com/api/subscriptions/id"

	payload := strings.NewReader("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")

	req, _ := http.NewRequest("PUT", 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 Método de pago actualizado
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}"

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

```java Método de pago actualizado
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://app.recurrente.com/api/subscriptions/id")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")
  .asString();
```

```php Método de pago actualizado
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.recurrente.com/api/subscriptions/id', [
  'body' => '{
  "payment_method_id": "pay_m_7v5ie3pw"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Método de pago actualizado
using RestSharp;

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

```swift Método de pago actualizado
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/subscriptions/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Suscripción pausada

**Request**

```json
{
  "payment_method_id": "pay_m_7v5ie3pw"
}
```

**Response**

```json
{
  "id": "su_nehndm7j",
  "description": "One Free-Testable Banana",
  "status": "paused",
  "resumes_on": "2025-06-01"
}
```

**SDK Code**

```python Suscripción pausada
import requests

url = "https://app.recurrente.com/api/subscriptions/id"

payload = { "payment_method_id": "pay_m_7v5ie3pw" }
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Suscripción pausada
const url = 'https://app.recurrente.com/api/subscriptions/id';
const options = {
  method: 'PUT',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"payment_method_id":"pay_m_7v5ie3pw"}'
};

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

```go Suscripción pausada
package main

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

func main() {

	url := "https://app.recurrente.com/api/subscriptions/id"

	payload := strings.NewReader("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")

	req, _ := http.NewRequest("PUT", 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 Suscripción pausada
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}"

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

```java Suscripción pausada
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://app.recurrente.com/api/subscriptions/id")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")
  .asString();
```

```php Suscripción pausada
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.recurrente.com/api/subscriptions/id', [
  'body' => '{
  "payment_method_id": "pay_m_7v5ie3pw"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Suscripción pausada
using RestSharp;

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

```swift Suscripción pausada
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/subscriptions/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Productos agregados/eliminados

**Request**

```json
{
  "payment_method_id": "pay_m_7v5ie3pw"
}
```

**Response**

```json
{
  "id": "su_nehndm7j",
  "description": "2 productos",
  "status": "active"
}
```

**SDK Code**

```python Productos agregados/eliminados
import requests

url = "https://app.recurrente.com/api/subscriptions/id"

payload = { "payment_method_id": "pay_m_7v5ie3pw" }
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Productos agregados/eliminados
const url = 'https://app.recurrente.com/api/subscriptions/id';
const options = {
  method: 'PUT',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"payment_method_id":"pay_m_7v5ie3pw"}'
};

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

```go Productos agregados/eliminados
package main

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

func main() {

	url := "https://app.recurrente.com/api/subscriptions/id"

	payload := strings.NewReader("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")

	req, _ := http.NewRequest("PUT", 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 Productos agregados/eliminados
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}"

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

```java Productos agregados/eliminados
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://app.recurrente.com/api/subscriptions/id")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.recurrente.com/api/subscriptions/id', [
  'body' => '{
  "payment_method_id": "pay_m_7v5ie3pw"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Productos agregados/eliminados
using RestSharp;

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

```swift Productos agregados/eliminados
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/subscriptions/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Producto agregado con cobro inmediato del prorrateo (now_and_charge)

**Request**

```json
{
  "payment_method_id": "pay_m_7v5ie3pw"
}
```

**Response**

```json
{
  "id": "su_nehndm7j",
  "description": "2 productos",
  "status": "active",
  "proration_charge": {
    "intent_id": "in_8kq2m4x1",
    "amount_in_cents": 4250,
    "currency": "GTQ",
    "status": "paid"
  }
}
```

**SDK Code**

```python Producto agregado con cobro inmediato del prorrateo (now_and_charge)
import requests

url = "https://app.recurrente.com/api/subscriptions/id"

payload = { "payment_method_id": "pay_m_7v5ie3pw" }
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Producto agregado con cobro inmediato del prorrateo (now_and_charge)
const url = 'https://app.recurrente.com/api/subscriptions/id';
const options = {
  method: 'PUT',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"payment_method_id":"pay_m_7v5ie3pw"}'
};

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

```go Producto agregado con cobro inmediato del prorrateo (now_and_charge)
package main

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

func main() {

	url := "https://app.recurrente.com/api/subscriptions/id"

	payload := strings.NewReader("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")

	req, _ := http.NewRequest("PUT", 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 Producto agregado con cobro inmediato del prorrateo (now_and_charge)
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}"

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

```java Producto agregado con cobro inmediato del prorrateo (now_and_charge)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://app.recurrente.com/api/subscriptions/id")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"payment_method_id\": \"pay_m_7v5ie3pw\"\n}")
  .asString();
```

```php Producto agregado con cobro inmediato del prorrateo (now_and_charge)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.recurrente.com/api/subscriptions/id', [
  'body' => '{
  "payment_method_id": "pay_m_7v5ie3pw"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

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

```csharp Producto agregado con cobro inmediato del prorrateo (now_and_charge)
using RestSharp;

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

```swift Producto agregado con cobro inmediato del prorrateo (now_and_charge)
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/subscriptions/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```