User Subscriptions (API) | Documentación de la API de Inbox Manager

User-controlled subscription endpoints (B2C) proxied to /auth/subscriptions*

GET/api/subscriptions

List subscriptions for the account selected by the bearer token acc claim. More Subscriptions

Responses

200application/json

schemaobject

datarequired

links

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/subscriptions" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/subscriptions";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/subscriptions";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/subscriptions", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/subscriptions", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/subscriptions", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/subscriptions", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/subscriptions")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/subscriptions", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/subscriptions");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/subscriptions/{subscription_id}/cancel

Cancel an active token account subscription immediately or at period end. More Subscriptions

Body application/json

timing

reasonstring

feedback

Responses

204

No Content

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/subscriptions/sub123/cancel" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"timing":"immediate","reason":"string","feedback":"customer_service"}'

const payload = {"timing":"immediate","reason":"string","feedback":"customer_service"};
const url = "${BASE_URL}/api/subscriptions/sub123/cancel";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"timing":"immediate","reason":"string","feedback":"customer_service"};
const url = "${BASE_URL}/api/subscriptions/sub123/cancel";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"timing":"immediate","reason":"string","feedback":"customer_service"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/sub123/cancel",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"timing":"immediate","reason":"string","feedback":"customer_service"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/sub123/cancel",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"timing":"immediate","reason":"string","feedback":"customer_service"};
const { body } = await request("${BASE_URL}/api/subscriptions/sub123/cancel", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"timing":"immediate","reason":"string","feedback":"customer_service"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/subscriptions/sub123/cancel", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"timing":"immediate","reason":"string","feedback":"customer_service"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/subscriptions/sub123/cancel", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"timing":"immediate","reason":"string","feedback":"customer_service"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/subscriptions/sub123/cancel", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"timing":"immediate","reason":"string","feedback":"customer_service"}
uri = URI("${BASE_URL}/api/subscriptions/sub123/cancel")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"timing":"immediate","reason":"string","feedback":"customer_service"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/subscriptions/sub123/cancel", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/subscriptions/sub123/cancel");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"timing\":\"immediate\",\"reason\":\"string\",\"feedback\":\"customer_service\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/subscriptions/{subscription_id}/change

Change plan/interval/currency for an active token account subscription. More Subscriptions

Body application/json

product_keystring

interval

currencystring

Responses

204

No Content

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/subscriptions/sub123/change" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"product_key":"string","interval":"month","currency":"string"}'

const payload = {"product_key":"string","interval":"month","currency":"string"};
const url = "${BASE_URL}/api/subscriptions/sub123/change";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"product_key":"string","interval":"month","currency":"string"};
const url = "${BASE_URL}/api/subscriptions/sub123/change";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"product_key":"string","interval":"month","currency":"string"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/sub123/change",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"product_key":"string","interval":"month","currency":"string"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/sub123/change",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"product_key":"string","interval":"month","currency":"string"};
const { body } = await request("${BASE_URL}/api/subscriptions/sub123/change", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"product_key":"string","interval":"month","currency":"string"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/subscriptions/sub123/change", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"product_key":"string","interval":"month","currency":"string"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/subscriptions/sub123/change", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"product_key":"string","interval":"month","currency":"string"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/subscriptions/sub123/change", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"product_key":"string","interval":"month","currency":"string"}
uri = URI("${BASE_URL}/api/subscriptions/sub123/change")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"product_key":"string","interval":"month","currency":"string"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/subscriptions/sub123/change", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/subscriptions/sub123/change");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"product_key\":\"string\",\"interval\":\"month\",\"currency\":\"string\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/subscriptions/features

List active subscription-derived features for the token account. More Subscriptions

Responses

200application/json

schemaobject

datarequired

links

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/subscriptions/features" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/subscriptions/features";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/subscriptions/features";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions/features",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions/features",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/subscriptions/features", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/subscriptions/features", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/subscriptions/features", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/subscriptions/features", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/subscriptions/features")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/subscriptions/features", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/subscriptions/features");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/subscriptions/identity

Get current token account subscription identity details. More Subscriptions

Responses

200application/json

schemaobject

datarequired

links

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/subscriptions/identity" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/subscriptions/identity";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/subscriptions/identity";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions/identity",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions/identity",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/subscriptions/identity", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/subscriptions/identity", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/subscriptions/identity", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/subscriptions/identity", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/subscriptions/identity")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/subscriptions/identity", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/subscriptions/identity");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/subscriptions/merchants

List billing merchants available for token account subscription operations. More Subscriptions

Responses

200application/json

schemaobject

datarequired

links

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/subscriptions/merchants" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/subscriptions/merchants";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/subscriptions/merchants";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions/merchants",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/subscriptions/merchants",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/subscriptions/merchants", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/subscriptions/merchants", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/subscriptions/merchants", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/subscriptions/merchants", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/subscriptions/merchants")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/subscriptions/merchants", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/subscriptions/merchants");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/subscriptions/stripe/checkout-session

Create a Stripe Checkout session URL for token account subscription purchase/change. More Subscriptions

Body application/json

price_idstringrequired

merchant_idstring

success_urlstring · urirequired

cancel_urlstring · urirequired

Responses

200application/json

schemaobject

urlstringrequired

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/subscriptions/stripe/checkout-session" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"}'

const payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"};
const url = "${BASE_URL}/api/subscriptions/stripe/checkout-session";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"};
const url = "${BASE_URL}/api/subscriptions/stripe/checkout-session";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/stripe/checkout-session",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/stripe/checkout-session",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"};
const { body } = await request("${BASE_URL}/api/subscriptions/stripe/checkout-session", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/subscriptions/stripe/checkout-session", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/subscriptions/stripe/checkout-session", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/subscriptions/stripe/checkout-session", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"}
uri = URI("${BASE_URL}/api/subscriptions/stripe/checkout-session")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"price_id":"string","merchant_id":"string","success_url":"string","cancel_url":"string"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/subscriptions/stripe/checkout-session", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/subscriptions/stripe/checkout-session");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"price_id\":\"string\",\"merchant_id\":\"string\",\"success_url\":\"string\",\"cancel_url\":\"string\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/subscriptions/stripe/checkout-session-sync

Finalize and sync results from a completed Stripe Checkout session for the token account. More Subscriptions

Body application/json

session_idstringrequired

merchant_idstring

Responses

200application/json

schemaobject

datarequired

links

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"session_id":"string","merchant_id":"string"}'

const payload = {"session_id":"string","merchant_id":"string"};
const url = "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"session_id":"string","merchant_id":"string"};
const url = "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"session_id":"string","merchant_id":"string"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"session_id":"string","merchant_id":"string"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"session_id":"string","merchant_id":"string"};
const { body } = await request("${BASE_URL}/api/subscriptions/stripe/checkout-session-sync", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"session_id":"string","merchant_id":"string"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"session_id":"string","merchant_id":"string"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"session_id":"string","merchant_id":"string"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"session_id":"string","merchant_id":"string"}
uri = URI("${BASE_URL}/api/subscriptions/stripe/checkout-session-sync")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"session_id":"string","merchant_id":"string"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/subscriptions/stripe/checkout-session-sync");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"session_id\":\"string\",\"merchant_id\":\"string\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/subscriptions/stripe/portal-session

Create a Stripe Customer Portal session URL for token account self-service management. More Subscriptions

Body application/json

return_urlstring · urirequired

localestring

flow_data

Responses

200application/json

schemaobject

urlstringrequired

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/subscriptions/stripe/portal-session" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"return_url":"string","locale":"string","flow_data":"value"}'

const payload = {"return_url":"string","locale":"string","flow_data":"value"};
const url = "${BASE_URL}/api/subscriptions/stripe/portal-session";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"return_url":"string","locale":"string","flow_data":"value"};
const url = "${BASE_URL}/api/subscriptions/stripe/portal-session";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"return_url":"string","locale":"string","flow_data":"value"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/stripe/portal-session",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"return_url":"string","locale":"string","flow_data":"value"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/stripe/portal-session",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"return_url":"string","locale":"string","flow_data":"value"};
const { body } = await request("${BASE_URL}/api/subscriptions/stripe/portal-session", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"return_url":"string","locale":"string","flow_data":"value"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/subscriptions/stripe/portal-session", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"return_url":"string","locale":"string","flow_data":"value"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/subscriptions/stripe/portal-session", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"return_url":"string","locale":"string","flow_data":"value"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/subscriptions/stripe/portal-session", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"return_url":"string","locale":"string","flow_data":"value"}
uri = URI("${BASE_URL}/api/subscriptions/stripe/portal-session")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"return_url":"string","locale":"string","flow_data":"value"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/subscriptions/stripe/portal-session", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/subscriptions/stripe/portal-session");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"return_url\":\"string\",\"locale\":\"string\",\"flow_data\":\"value\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/subscriptions/sync

Synchronize token account subscription state from billing provider systems. More Subscriptions

Body application/json

bodyobject

Responses

200application/json

schemaobject

datarequired

links

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/subscriptions/sync?allow_deletes=true" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{}'

const payload = {};
const url = "${BASE_URL}/api/subscriptions/sync?allow_deletes=true";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {};
const url = "${BASE_URL}/api/subscriptions/sync?allow_deletes=true";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/sync?allow_deletes=true",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/subscriptions/sync?allow_deletes=true",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {};
const { body } = await request("${BASE_URL}/api/subscriptions/sync?allow_deletes=true", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/subscriptions/sync?allow_deletes=true", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/subscriptions/sync?allow_deletes=true", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/subscriptions/sync?allow_deletes=true", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {}
uri = URI("${BASE_URL}/api/subscriptions/sync?allow_deletes=true")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/subscriptions/sync?allow_deletes=true", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/subscriptions/sync?allow_deletes=true");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

ProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

ValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

Features

Suscripciones

Types

Sobre de proxy de suscripción

User Subscriptions

Contents

List subscriptions

Cancel subscription

Change subscription

List subscription features

Get subscription identity

List subscription merchants

Create Stripe checkout session

Sync Stripe checkout session

Create Stripe portal session

Sync subscriptions

Models

Features

Types

Contents

Models

Related Features and Types

Features

Types