Documentação

Introdução

A API da Txenka é organizada em torno de payment_intents — cada pagamento que crias e confirmas. Todos os pedidos e respostas usam JSON, e o URL base é https://api.txenka.com/api/v1.

Autenticação

Todas as chamadas autenticadas usam a tua API key no cabeçalho Authorization. Encontras a tua chave em Programadores → API Keys no dashboard — usa txk_test_… para testar sem processar dinheiro real, e txk_live_… em produção. Cada chave escolhe as suas próprias permissões (scopes) — dá a cada integração só o acesso de que precisa.

HTTP Header

Authorization: Bearer txk_test_8f2a3c9d1e...

Scopes

Cada API Key escolhe os seus próprios scopes na criação — restringe cada integração ao mínimo de que precisa. Uma publishable key só pode ter payments:read, payments:confirm e transactions:read — nunca payments:write, que criaria Payment Intents com valor arbitrário.

payments:read Ler Payment Intents

payments:write Criar Payment Intents

payments:confirm Confirmar um Payment Intent já criado (seguro em publishable key)

payments:cancel Cancelar pagamentos

transactions:read Ler transacções

refunds:read Ler reembolsos

refunds:write Criar reembolsos

webhooks:read Ler webhooks

webhooks:write Gerir webhooks

customers:read Ler clientes

customers:write Gerir clientes

products:read Ler produtos

products:write Gerir produtos

invoices:read Ler facturas

invoices:write Gerir facturas

payment_links:read Ler links de pagamento

payment_links:write Gerir links de pagamento

bank_accounts:read Ler contas bancárias de recebimento

bank_accounts:write Gerir contas bancárias de recebimento

payout_accounts:read Ler contas de saque

payout_accounts:write Gerir contas de saque

withdrawals:read Ler levantamentos

withdrawals:write Solicitar levantamentos

billing:read Ler facturação/subscrição

billing:write Gerir facturação/subscrição

devices:read Ler dispositivos emparelhados

devices:write Gerir dispositivos emparelhados

api_keys:read Listar API Keys

api_keys:write Criar, editar e revogar API Keys

Criar um pagamento

Um payment_intent representa uma cobrança. O valor é sempre em centavos (2450 = 24,50 MZN). amount, customer_email e customer_name são obrigatórios; payment_method é opcional — se omitido, o cliente escolhe o método na própria página de checkout.

curl -X POST https://api.txenka.com/api/v1/payment-intents \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 2450,
    "currency": "MZN",
    "payment_method": "mpesa",
    "customer_phone": "258840000000",
    "customer_email": "cliente@exemplo.com",
    "customer_name": "Ana Machava",
    "description": "Pedido #1042",
    "merchant_reference": "PEDIDO-1042"
  }'

const res = await fetch('https://api.txenka.com/api/v1/payment-intents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    amount: 2450,
    currency: 'MZN',
    payment_method: 'mpesa',
    customer_phone: '258840000000',
    customer_email: 'cliente@exemplo.com',
    customer_name: 'Ana Machava',
    description: 'Pedido #1042',
    merchant_reference: 'PEDIDO-1042',
  }),
});
const intent = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-intents');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'amount' => 2450,
        'currency' => 'MZN',
        'payment_method' => 'mpesa',
        'customer_phone' => '258840000000',
        'customer_email' => 'cliente@exemplo.com',
        'customer_name' => 'Ana Machava',
        'description' => 'Pedido #1042',
        'merchant_reference' => 'PEDIDO-1042',
    ]),
]);
$intent = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/payment-intents",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "amount": 2450,
        "currency": "MZN",
        "payment_method": "mpesa",
        "customer_phone": "258840000000",
        "customer_email": "cliente@exemplo.com",
        "customer_name": "Ana Machava",
        "description": "Pedido #1042",
        "merchant_reference": "PEDIDO-1042",
    },
)
intent = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-intents')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  amount: 2450,
  currency: 'MZN',
  payment_method: 'mpesa',
  customer_phone: '258840000000',
  customer_email: 'cliente@exemplo.com',
  customer_name: 'Ana Machava',
  description: 'Pedido #1042',
  merchant_reference: 'PEDIDO-1042',
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
intent = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "amount":              2450,
    "currency":            "MZN",
    "payment_method":      "mpesa",
    "customer_phone":      "258840000000",
    "customer_email":      "cliente@exemplo.com",
    "customer_name":       "Ana Machava",
    "description":         "Pedido #1042",
    "merchant_reference":  "PEDIDO-1042",
})

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/payment-intents", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"amount":2450,"currency":"MZN","payment_method":"mpesa",
     "customer_phone":"258840000000","customer_email":"cliente@exemplo.com",
     "customer_name":"Ana Machava","description":"Pedido #1042",
     "merchant_reference":"PEDIDO-1042"}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-intents"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

A resposta já inclui um checkout_url pronto a usar — redirecionas o cliente para lá e a Txenka trata da confirmação por ti, sem precisares de implementar o passo seguinte. client_secret só autoriza ler/confirmar este pagamento específico, nunca os teus outros intents — seguro para partilhar por qualquer canal (WhatsApp, SMS, email).

Response

{
  "object": "payment_intent",
  "id": "01HX4K9GVZ3QY8N7T2WPJD5R6E",
  "amount": 2450,
  "amount_decimal": "24.50",
  "currency": "MZN",
  "status": "requires_confirmation",
  "payment_method": "mpesa",
  "description": "Pedido #1042",
  "merchant_reference": "PEDIDO-1042",
  "merchant": { "name": "A Tua Loja", "logo_url": null },
  "available_payment_methods": [
    { "key": "mpesa", "name": "M-Pesa", "icon": "...", "type": "wallet", "needs_phone": true, "customer_instructions": "..." }
  ],
  "checkout_url": "https://pay.txenka.com/checkout/01HX4K9GVZ3QY8N7T2WPJD5R6E_secret_a1b2c3...",
  "client_secret": "01HX4K9GVZ3QY8N7T2WPJD5R6E_secret_a1b2c3...",
  "customer": { "email": "cliente@exemplo.com", "phone": "+258840000000", "name": "Ana Machava" },
  "success_url": null,
  "cancel_url": null,
  "failure_code": null,
  "failure_message": null,
  "metadata": {},
  "latest_transaction": null,
  "created_at": "2026-07-30T10:00:00+00:00",
  "updated_at": "2026-07-30T10:00:00+00:00",
  "cancelled_at": null,
  "expires_at": "2026-07-30T11:00:00+00:00"
}

Confirmar o pagamento

Confirmar dispara o pedido junto do método escolhido — por exemplo, um pedido STK push no telemóvel do cliente para M-Pesa/e-Mola.

curl -X POST https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm',
  { method: 'POST', headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const result = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$result = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
result = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
result = JSON.parse(res.body)

req, _ := http.NewRequest(
    "POST",
    "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm",
    nil,
)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/confirm"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .POST(HttpRequest.BodyPublishers.noBody())
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Response

{
  "object": "payment_intent",
  "id": "01HX4K9GVZ3QY8N7T2WPJD5R6E",
  "status": "processing",
  "payment_method": "mpesa",
  "failure_code": null,
  "failure_message": null,
  "latest_transaction": {
    "object": "transaction",
    "id": "01HABCXYZ...",
    "provider_reference": "ws_CO_2607261...",
    "status": "pending"
  }
}

O status devolvido pode ser succeeded (imediato), processing (aguarda confirmação assíncrona — o resultado final chega por webhook) ou failed (ver failure_code/failure_message).

Um failed não é definitivo — chama POST /payment-intents/{id}/reset-method para limpar o método e voltar a confirmar com outro, sem criar um novo intent. Isto é diferente de cancelar (que termina o intent para sempre).

Gerir Payment Intents

Além de criar e confirmar, consulta o histórico de intents, cancela-os definitivamente ou deixa o cliente escolher outro método sem perder o intent.

Listar

Filtra por status, payment_method, from/to (datas) e pagina com limit.

curl "https://api.txenka.com/api/v1/payment-intents?status=succeeded&limit=20" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/payment-intents?status=succeeded&limit=20',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-intents?status=succeeded&limit=20');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$intents = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/payment-intents",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"status": "succeeded", "limit": 20},
)
intents = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-intents?status=succeeded&limit=20')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
intents = JSON.parse(res.body)['data']

req, _ := http.NewRequest(
    "GET",
    "https://api.txenka.com/api/v1/payment-intents?status=succeeded&limit=20",
    nil,
)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-intents?status=succeeded&limit=20"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar um

curl https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const intent = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$intent = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
intent = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
intent = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Cancelar

Termina definitivamente o intent — igual ao PaymentIntent.cancel do Stripe. Uma vez cancelado (ou já succeeded), não há volta atrás — usa reset-method abaixo se só precisas de deixar o cliente tentar outro método.

curl -X POST https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel',
  { method: 'POST', headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const intent = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$intent = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
intent = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
intent = JSON.parse(res.body)

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/cancel"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .POST(HttpRequest.BodyPublishers.noBody())
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Escolher outro método (reset-method)

Diferente de cancelar: limpa apenas o payment_method da tentativa actual e volta o intent a requires_payment_method, sem terminar o intent nem o seu checkout_url. Útil quando uma tentativa síncrona (mpesa/card) foi recusada, ou uma tentativa manual/assíncrona (transferência bancária, SMS relay) ficou pendente e o cliente desistiu — deixa-o escolher outro método no mesmo link, em vez de teres de criar um novo Payment Intent. Permitido a partir de qualquer estado não-terminal, incluindo failed (uma recusa é para ser retentada); bloqueado só a partir de succeeded/cancelled.

curl -X POST https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method',
  { method: 'POST', headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const intent = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$intent = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
intent = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
intent = JSON.parse(res.body)

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-intents/01HX4K9GVZ3QY8N7T2WPJD5R6E/reset-method"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .POST(HttpRequest.BodyPublishers.noBody())
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Transacções

Cada tentativa de cobrança contra um Payment Intent gera uma transacção — um intent pode ter várias, se o cliente falhar e tentar de novo.

Listar

curl "https://api.txenka.com/api/v1/transactions?status=succeeded&payment_method=mpesa" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/transactions?status=succeeded&payment_method=mpesa',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/transactions?status=succeeded&payment_method=mpesa');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$transactions = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/transactions",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"status": "succeeded", "payment_method": "mpesa"},
)
transactions = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/transactions?status=succeeded&payment_method=mpesa')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
transactions = JSON.parse(res.body)['data']

req, _ := http.NewRequest(
    "GET",
    "https://api.txenka.com/api/v1/transactions?status=succeeded&payment_method=mpesa",
    nil,
)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/transactions?status=succeeded&payment_method=mpesa"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar uma

curl https://api.txenka.com/api/v1/transactions/txn_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/transactions/txn_01hx4k9…',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const transaction = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/transactions/txn_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$transaction = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/transactions/txn_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
transaction = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/transactions/txn_01hx4k9…')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
transaction = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/transactions/txn_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/transactions/txn_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Response

{
  "object": "transaction",
  "id": "txn_01hx4k9…",
  "payment_intent_id": "01HX4K9GVZ3QY8N7T2WPJD5R6E",
  "amount": 2450,
  "currency": "MZN",
  "status": "succeeded",
  "payment_method": "mpesa",
  "provider_reference": "MP240730.1234.A56789",
  "amount_refunded": 0,
  "is_refundable": true
}

Reembolsos

Reembolsa total ou parcialmente uma transacção bem-sucedida. Para métodos com reversão automática, o estado muda logo; para os manuais (transferência bancária, SMS relay) fica pending até seres notificado por webhook.

Listar

curl https://api.txenka.com/api/v1/refunds \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/refunds', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/refunds');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$refunds = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/refunds",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
refunds = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/refunds')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
refunds = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/refunds", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/refunds"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Criar (numa transacção)

amount é opcional — omitido, reembolsa o total ainda não reembolsado. reason aceita duplicate, fraudulent, requested_by_customer ou other.

curl -X POST https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 1000,
    "reason": "requested_by_customer",
    "notes": "Cliente desistiu da encomenda"
  }'

const res = await fetch(
  'https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      amount: 1000,
      reason: 'requested_by_customer',
      notes: 'Cliente desistiu da encomenda',
    }),
  }
);
const refund = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'amount' => 1000,
        'reason' => 'requested_by_customer',
        'notes' => 'Cliente desistiu da encomenda',
    ]),
]);
$refund = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "amount": 1000,
        "reason": "requested_by_customer",
        "notes": "Cliente desistiu da encomenda",
    },
)
refund = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  amount: 1000,
  reason: 'requested_by_customer',
  notes: 'Cliente desistiu da encomenda',
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
refund = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "amount": 1000,
    "reason": "requested_by_customer",
    "notes":  "Cliente desistiu da encomenda",
})

req, _ := http.NewRequest(
    "POST",
    "https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds",
    bytes.NewBuffer(body),
)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"amount":1000,"reason":"requested_by_customer",
     "notes":"Cliente desistiu da encomenda"}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/transactions/txn_01hx4k9…/refunds"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar um

curl https://api.txenka.com/api/v1/refunds/re_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/refunds/re_01hx4k9…', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const refund = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/refunds/re_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$refund = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/refunds/re_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
refund = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/refunds/re_01hx4k9…')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
refund = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/refunds/re_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/refunds/re_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Clientes

Um registo simples do teu cliente — nome, email, telefone — para reutilizares em facturas e para pesquisares o histórico de pagamentos por pessoa.

Listar

curl "https://api.txenka.com/api/v1/customers?search=Ana&limit=25" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/customers?search=Ana&limit=25',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/customers?search=Ana&limit=25');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$customers = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/customers",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"search": "Ana", "limit": 25},
)
customers = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/customers?search=Ana&limit=25')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
customers = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/customers?search=Ana&limit=25", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/customers?search=Ana&limit=25"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Criar

curl -X POST https://api.txenka.com/api/v1/customers \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Ana Machava",
    "email": "ana@example.com",
    "phone": "258840000000",
    "country": "MZ"
  }'

const res = await fetch('https://api.txenka.com/api/v1/customers', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Ana Machava',
    email: 'ana@example.com',
    phone: '258840000000',
    country: 'MZ',
  }),
});
const customer = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/customers');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Ana Machava',
        'email' => 'ana@example.com',
        'phone' => '258840000000',
        'country' => 'MZ',
    ]),
]);
$customer = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/customers",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "name": "Ana Machava",
        "email": "ana@example.com",
        "phone": "258840000000",
        "country": "MZ",
    },
)
customer = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/customers')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  name: 'Ana Machava',
  email: 'ana@example.com',
  phone: '258840000000',
  country: 'MZ',
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
customer = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "name":    "Ana Machava",
    "email":   "ana@example.com",
    "phone":   "258840000000",
    "country": "MZ",
})

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/customers", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"name":"Ana Machava","email":"ana@example.com",
     "phone":"258840000000","country":"MZ"}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/customers"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar um

curl https://api.txenka.com/api/v1/customers/cus_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/customers/cus_01hx4k9…', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const customer = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/customers/cus_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$customer = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/customers/cus_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
customer = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/customers/cus_01hx4k9…')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
customer = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/customers/cus_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/customers/cus_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Actualizar

curl -X PATCH https://api.txenka.com/api/v1/customers/cus_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"phone": "258850000000"}'

const res = await fetch('https://api.txenka.com/api/v1/customers/cus_01hx4k9…', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ phone: '258850000000' }),
});
const customer = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/customers/cus_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['phone' => '258850000000']),
]);
$customer = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/customers/cus_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"phone": "258850000000"},
)
customer = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/customers/cus_01hx4k9…')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { phone: '258850000000' }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
customer = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{"phone": "258850000000"})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/customers/cus_01hx4k9…", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/customers/cus_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\\"phone\\":\\"258850000000\\"}"))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Eliminar

curl -X DELETE https://api.txenka.com/api/v1/customers/cus_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

await fetch('https://api.txenka.com/api/v1/customers/cus_01hx4k9…', {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});

$ch = curl_init('https://api.txenka.com/api/v1/customers/cus_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
curl_exec($ch);

import requests

requests.delete(
    "https://api.txenka.com/api/v1/customers/cus_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)

require 'net/http'

uri = URI('https://api.txenka.com/api/v1/customers/cus_01hx4k9…')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

req, _ := http.NewRequest("DELETE", "https://api.txenka.com/api/v1/customers/cus_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/customers/cus_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .DELETE()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Produtos

Um catálogo simples para reutilizares em facturas e links de pagamento. Nota: ao contrário de payment_intents, price aqui é um valor decimal na unidade principal (899.90 = 899,90 MZN) — a API converte para centavos internamente.

Listar

curl "https://api.txenka.com/api/v1/products?status=active&search=camisa" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/products?status=active&search=camisa',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/products?status=active&search=camisa');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$products = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/products",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"status": "active", "search": "camisa"},
)
products = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/products?status=active&search=camisa')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
products = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/products?status=active&search=camisa", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/products?status=active&search=camisa"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Criar

curl -X POST https://api.txenka.com/api/v1/products \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Camisa polo",
    "price": 899.90,
    "currency": "MZN",
    "sku": "POLO-001"
  }'

const res = await fetch('https://api.txenka.com/api/v1/products', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Camisa polo',
    price: 899.90,
    currency: 'MZN',
    sku: 'POLO-001',
  }),
});
const product = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/products');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Camisa polo',
        'price' => 899.90,
        'currency' => 'MZN',
        'sku' => 'POLO-001',
    ]),
]);
$product = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/products",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "name": "Camisa polo",
        "price": 899.90,
        "currency": "MZN",
        "sku": "POLO-001",
    },
)
product = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/products')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  name: 'Camisa polo',
  price: 899.90,
  currency: 'MZN',
  sku: 'POLO-001',
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
product = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "name":     "Camisa polo",
    "price":    899.90,
    "currency": "MZN",
    "sku":      "POLO-001",
})

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/products", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"name":"Camisa polo","price":899.90,
     "currency":"MZN","sku":"POLO-001"}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/products"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar um

curl https://api.txenka.com/api/v1/products/prod_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/products/prod_01hx4k9…', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const product = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/products/prod_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$product = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/products/prod_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
product = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/products/prod_01hx4k9…')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
product = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/products/prod_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/products/prod_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Actualizar

curl -X PATCH https://api.txenka.com/api/v1/products/prod_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"price": 949.90, "status": "inactive"}'

const res = await fetch('https://api.txenka.com/api/v1/products/prod_01hx4k9…', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ price: 949.90, status: 'inactive' }),
});
const product = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/products/prod_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['price' => 949.90, 'status' => 'inactive']),
]);
$product = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/products/prod_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"price": 949.90, "status": "inactive"},
)
product = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/products/prod_01hx4k9…')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { price: 949.90, status: 'inactive' }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
product = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{"price": 949.90, "status": "inactive"})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/products/prod_01hx4k9…", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/products/prod_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\\"price\\":949.90,\\"status\\":\\"inactive\\"}"))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Eliminar

curl -X DELETE https://api.txenka.com/api/v1/products/prod_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

await fetch('https://api.txenka.com/api/v1/products/prod_01hx4k9…', {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});

$ch = curl_init('https://api.txenka.com/api/v1/products/prod_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
curl_exec($ch);

import requests

requests.delete(
    "https://api.txenka.com/api/v1/products/prod_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)

require 'net/http'

uri = URI('https://api.txenka.com/api/v1/products/prod_01hx4k9…')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

req, _ := http.NewRequest("DELETE", "https://api.txenka.com/api/v1/products/prod_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/products/prod_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .DELETE()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Facturas

Agrega vários line_items num total a cobrar a um cliente, com prazo de pagamento. Mesma convenção decimal dos Produtos para preços/quantidades.

Listar

curl "https://api.txenka.com/api/v1/invoices?status=sent&limit=25" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/invoices?status=sent&limit=25',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/invoices?status=sent&limit=25');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$invoices = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/invoices",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"status": "sent", "limit": 25},
)
invoices = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/invoices?status=sent&limit=25')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
invoices = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/invoices?status=sent&limit=25", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/invoices?status=sent&limit=25"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Criar

O número da factura (INV-2026-0001) é gerado automaticamente. Os totais (subtotal, total) são calculados a partir de line_items, não enviados por ti.

curl -X POST https://api.txenka.com/api/v1/invoices \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "cus_01hx4k9…",
    "issued_at": "2026-07-30",
    "due_at": "2026-08-13",
    "line_items": [
      {"description": "Camisa polo", "quantity": 2, "unit_price": 899.90}
    ]
  }'

const res = await fetch('https://api.txenka.com/api/v1/invoices', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    customer_id: 'cus_01hx4k9…',
    issued_at: '2026-07-30',
    due_at: '2026-08-13',
    line_items: [{ description: 'Camisa polo', quantity: 2, unit_price: 899.90 }],
  }),
});
const invoice = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/invoices');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'customer_id' => 'cus_01hx4k9…',
        'issued_at' => '2026-07-30',
        'due_at' => '2026-08-13',
        'line_items' => [
            ['description' => 'Camisa polo', 'quantity' => 2, 'unit_price' => 899.90],
        ],
    ]),
]);
$invoice = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/invoices",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "customer_id": "cus_01hx4k9…",
        "issued_at": "2026-07-30",
        "due_at": "2026-08-13",
        "line_items": [
            {"description": "Camisa polo", "quantity": 2, "unit_price": 899.90},
        ],
    },
)
invoice = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/invoices')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  customer_id: 'cus_01hx4k9…',
  issued_at: '2026-07-30',
  due_at: '2026-08-13',
  line_items: [{ description: 'Camisa polo', quantity: 2, unit_price: 899.90 }],
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
invoice = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "customer_id": "cus_01hx4k9…",
    "issued_at":   "2026-07-30",
    "due_at":      "2026-08-13",
    "line_items": []map[string]any{
        {"description": "Camisa polo", "quantity": 2, "unit_price": 899.90},
    },
})

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/invoices", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"customer_id":"cus_01hx4k9…","issued_at":"2026-07-30","due_at":"2026-08-13",
     "line_items":[{"description":"Camisa polo","quantity":2,"unit_price":899.90}]}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/invoices"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar uma

curl https://api.txenka.com/api/v1/invoices/inv_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const invoice = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$invoice = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/invoices/inv_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
invoice = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
invoice = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/invoices/inv_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/invoices/inv_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Actualizar (estado, notas, prazo)

curl -X PATCH https://api.txenka.com/api/v1/invoices/inv_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"status": "paid", "paid_at": "2026-07-30T10:00:00Z"}'

const res = await fetch('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ status: 'paid', paid_at: '2026-07-30T10:00:00Z' }),
});
const invoice = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['status' => 'paid', 'paid_at' => '2026-07-30T10:00:00Z']),
]);
$invoice = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/invoices/inv_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"status": "paid", "paid_at": "2026-07-30T10:00:00Z"},
)
invoice = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { status: 'paid', paid_at: '2026-07-30T10:00:00Z' }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
invoice = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{"status": "paid", "paid_at": "2026-07-30T10:00:00Z"})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/invoices/inv_01hx4k9…", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/invoices/inv_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\\"status\\":\\"paid\\",\\"paid_at\\":\\"2026-07-30T10:00:00Z\\"}"))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Eliminar

curl -X DELETE https://api.txenka.com/api/v1/invoices/inv_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

await fetch('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…', {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});

$ch = curl_init('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
curl_exec($ch);

import requests

requests.delete(
    "https://api.txenka.com/api/v1/invoices/inv_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)

require 'net/http'

uri = URI('https://api.txenka.com/api/v1/invoices/inv_01hx4k9…')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

req, _ := http.NewRequest("DELETE", "https://api.txenka.com/api/v1/invoices/inv_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/invoices/inv_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .DELETE()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Links de Pagamento

Uma página de checkout hospedada e reutilizável, com o teu próprio slug — para partilhares por WhatsApp/redes sociais sem escrever código. Mesma convenção decimal para amount.

Listar

curl "https://api.txenka.com/api/v1/payment-links?status=active" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/payment-links?status=active',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-links?status=active');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$links = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/payment-links",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"status": "active"},
)
links = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-links?status=active')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
links = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/payment-links?status=active", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-links?status=active"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Criar

curl -X POST https://api.txenka.com/api/v1/payment-links \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Pedido personalizado",
    "amount": 500.00,
    "currency": "MZN"
  }'

const res = await fetch('https://api.txenka.com/api/v1/payment-links', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Pedido personalizado',
    amount: 500.00,
    currency: 'MZN',
  }),
});
const link = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-links');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Pedido personalizado',
        'amount' => 500.00,
        'currency' => 'MZN',
    ]),
]);
$link = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/payment-links",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"name": "Pedido personalizado", "amount": 500.00, "currency": "MZN"},
)
link = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-links')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { name: 'Pedido personalizado', amount: 500.00, currency: 'MZN' }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
link = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "name":     "Pedido personalizado",
    "amount":   500.00,
    "currency": "MZN",
})

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/payment-links", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"name":"Pedido personalizado","amount":500.00,"currency":"MZN"}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-links"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar um

curl https://api.txenka.com/api/v1/payment-links/pl_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const link = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$link = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
link = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
link = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Actualizar

curl -X PATCH https://api.txenka.com/api/v1/payment-links/pl_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"status": "inactive"}'

const res = await fetch('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ status: 'inactive' }),
});
const link = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['status' => 'inactive']),
]);
$link = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"status": "inactive"},
)
link = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { status: 'inactive' }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
link = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{"status": "inactive"})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\\"status\\":\\"inactive\\"}"))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Eliminar

curl -X DELETE https://api.txenka.com/api/v1/payment-links/pl_01hx4k9… \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

await fetch('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…', {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});

$ch = curl_init('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
curl_exec($ch);

import requests

requests.delete(
    "https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)

require 'net/http'

uri = URI('https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

req, _ := http.NewRequest("DELETE", "https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-links/pl_01hx4k9…"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .DELETE()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Perfil da Loja

Dados públicos e de contacto da tua conta, e quais métodos de pagamento estão activos e como estão configurados.

Consultar o perfil

curl https://api.txenka.com/api/v1/merchants/me \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/merchants/me', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const merchant = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/merchants/me');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$merchant = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/merchants/me",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
merchant = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/merchants/me')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
merchant = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/merchants/me", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/merchants/me"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Actualizar o perfil

curl -X PATCH https://api.txenka.com/api/v1/merchants/me \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"support_email": "suporte@minhaloja.co.mz", "website": "https://minhaloja.co.mz"}'

const res = await fetch('https://api.txenka.com/api/v1/merchants/me', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    support_email: 'suporte@minhaloja.co.mz',
    website: 'https://minhaloja.co.mz',
  }),
});
const merchant = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/merchants/me');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'support_email' => 'suporte@minhaloja.co.mz',
        'website' => 'https://minhaloja.co.mz',
    ]),
]);
$merchant = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/merchants/me",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "support_email": "suporte@minhaloja.co.mz",
        "website": "https://minhaloja.co.mz",
    },
)
merchant = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/merchants/me')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  support_email: 'suporte@minhaloja.co.mz',
  website: 'https://minhaloja.co.mz',
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
merchant = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "support_email": "suporte@minhaloja.co.mz",
    "website":       "https://minhaloja.co.mz",
})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/merchants/me", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"support_email":"suporte@minhaloja.co.mz",
     "website":"https://minhaloja.co.mz"}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/merchants/me"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Métodos activos

enabled_methods só pode conter métodos já autorizados pela Txenka para a tua conta (ver merchant.payment_methods.authorized na resposta de GET /merchants/me) — usa o endpoint de pedido abaixo para solicitar um novo.

curl -X PATCH https://api.txenka.com/api/v1/merchants/me/payment-methods \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"enabled_methods": ["mpesa", "emola", "card"]}'

const res = await fetch('https://api.txenka.com/api/v1/merchants/me/payment-methods', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ enabled_methods: ['mpesa', 'emola', 'card'] }),
});
const merchant = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/merchants/me/payment-methods');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['enabled_methods' => ['mpesa', 'emola', 'card']]),
]);
$merchant = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/merchants/me/payment-methods",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"enabled_methods": ["mpesa", "emola", "card"]},
)
merchant = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/merchants/me/payment-methods')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { enabled_methods: ['mpesa', 'emola', 'card'] }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
merchant = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{"enabled_methods": []string{"mpesa", "emola", "card"}})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/merchants/me/payment-methods", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"enabled_methods":["mpesa","emola","card"]}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/merchants/me/payment-methods"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar configuração de um método

curl https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const config = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$config = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
config = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
config = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Configurar um método (direct vs custom)

mode: "direct" usa a integração oficial/pooled da Txenka; mode: "custom" usa as tuas próprias credenciais junto do operador/banco (guardadas cifradas). Requer KYC e KYB aprovados.

curl -X PATCH https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "custom",
    "credentials": {"api_key": "...", "public_key": "..."},
    "enabled": true
  }'

const res = await fetch('https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    mode: 'custom',
    credentials: { api_key: '...', public_key: '...' },
    enabled: true,
  }),
});
const config = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'mode' => 'custom',
        'credentials' => ['api_key' => '...', 'public_key' => '...'],
        'enabled' => true,
    ]),
]);
$config = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "mode": "custom",
        "credentials": {"api_key": "...", "public_key": "..."},
        "enabled": True,
    },
)
config = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  mode: 'custom',
  credentials: { api_key: '...', public_key: '...' },
  enabled: true,
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
config = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "mode":        "custom",
    "credentials": map[string]any{"api_key": "...", "public_key": "..."},
    "enabled":     true,
})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"mode":"custom","credentials":{"api_key":"...","public_key":"..."},
     "enabled":true}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/merchants/me/payment-methods/mpesa"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Pedir autorização para um método

Envia um pedido a um administrador para activar um método ainda não autorizado para a tua conta (ex. bank_transfer_atm). Idempotente — repetir o pedido apenas reabre um pedido rejeitado/pendente existente.

curl -X POST https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request',
  { method: 'POST', headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const merchant = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$merchant = json_decode(curl_exec($ch), true);

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
merchant = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
merchant = JSON.parse(res.body)

req, _ := http.NewRequest(
    "POST",
    "https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request",
    nil,
)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/merchants/me/payment-methods/bank_transfer_atm/request"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .POST(HttpRequest.BodyPublishers.noBody())
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

API Keys

Cria e gere as tuas chaves de API — cada uma com o seu próprio tipo (test/live), scopes e, opcionalmente, whitelist de IPs e expiração.

Listar

curl https://api.txenka.com/api/v1/api-keys \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/api-keys', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/api-keys');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$keys = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/api-keys",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
keys = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/api-keys')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
keys = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/api-keys", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/api-keys"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Criar

O valor completo da chave só é devolvido nesta resposta — guarda-o já, não é possível consultá-lo depois.

curl -X POST https://api.txenka.com/api/v1/api-keys \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Integração e-commerce",
    "type": "test",
    "kind": "secret",
    "scopes": ["payments:read", "payments:write", "payments:confirm"]
  }'

const res = await fetch('https://api.txenka.com/api/v1/api-keys', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Integração e-commerce',
    type: 'test',
    kind: 'secret',
    scopes: ['payments:read', 'payments:write', 'payments:confirm'],
  }),
});
const key = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/api-keys');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name' => 'Integração e-commerce',
        'type' => 'test',
        'kind' => 'secret',
        'scopes' => ['payments:read', 'payments:write', 'payments:confirm'],
    ]),
]);
$key = json_decode(curl_exec($ch), true);
// $key['key'] só vem aqui, na criação — guarda-o já.

import requests

response = requests.post(
    "https://api.txenka.com/api/v1/api-keys",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={
        "name": "Integração e-commerce",
        "type": "test",
        "kind": "secret",
        "scopes": ["payments:read", "payments:write", "payments:confirm"],
    },
)
key = response.json()  # key["key"] só vem aqui, na criação — guarda-o já.

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/api-keys')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = {
  name: 'Integração e-commerce',
  type: 'test',
  kind: 'secret',
  scopes: ['payments:read', 'payments:write', 'payments:confirm'],
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
key = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{
    "name":   "Integração e-commerce",
    "type":   "test",
    "kind":   "secret",
    "scopes": []string{"payments:read", "payments:write", "payments:confirm"},
})

req, _ := http.NewRequest("POST", "https://api.txenka.com/api/v1/api-keys", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var body = """
    {"name":"Integração e-commerce","type":"test","kind":"secret",
     "scopes":["payments:read","payments:write","payments:confirm"]}""";

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/api-keys"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Consultar uma

curl https://api.txenka.com/api/v1/api-keys/17 \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/api-keys/17', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const key = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/api-keys/17');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$key = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/api-keys/17",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
key = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/api-keys/17')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
key = JSON.parse(res.body)

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/api-keys/17", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/api-keys/17"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Actualizar (nome, scopes, whitelist de IPs)

curl -X PATCH https://api.txenka.com/api/v1/api-keys/17 \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..." \
  -H "Content-Type: application/json" \
  -d '{"scopes": ["payments:read", "transactions:read"]}'

const res = await fetch('https://api.txenka.com/api/v1/api-keys/17', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer txk_test_8f2a3c9d1e...',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ scopes: ['payments:read', 'transactions:read'] }),
});
const key = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/api-keys/17');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer txk_test_8f2a3c9d1e...',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['scopes' => ['payments:read', 'transactions:read']]),
]);
$key = json_decode(curl_exec($ch), true);

import requests

response = requests.patch(
    "https://api.txenka.com/api/v1/api-keys/17",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    json={"scopes": ["payments:read", "transactions:read"]},
)
key = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/api-keys/17')
req = Net::HTTP::Patch.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'
req['Content-Type'] = 'application/json'
req.body = { scopes: ['payments:read', 'transactions:read'] }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
key = JSON.parse(res.body)

body, _ := json.Marshal(map[string]any{"scopes": []string{"payments:read", "transactions:read"}})

req, _ := http.NewRequest("PATCH", "https://api.txenka.com/api/v1/api-keys/17", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")
req.Header.Set("Content-Type", "application/json")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/api-keys/17"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\\"scopes\\":[\\"payments:read\\",\\"transactions:read\\"]}"))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Revogar

curl -X DELETE https://api.txenka.com/api/v1/api-keys/17 \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

await fetch('https://api.txenka.com/api/v1/api-keys/17', {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});

$ch = curl_init('https://api.txenka.com/api/v1/api-keys/17');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
curl_exec($ch);

import requests

requests.delete(
    "https://api.txenka.com/api/v1/api-keys/17",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)

require 'net/http'

uri = URI('https://api.txenka.com/api/v1/api-keys/17')
req = Net::HTTP::Delete.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

req, _ := http.NewRequest("DELETE", "https://api.txenka.com/api/v1/api-keys/17", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/api-keys/17"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .DELETE()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Listar scopes disponíveis

Devolve o mesmo catálogo de scopes descrito na secção de Autenticação — útil para construíres a UI de selecção de scopes sem hardcodar a lista.

curl https://api.txenka.com/api/v1/api-keys/scopes \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/api-keys/scopes', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const { scopes } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/api-keys/scopes');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$scopes = json_decode(curl_exec($ch), true)['scopes'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/api-keys/scopes",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
scopes = response.json()["scopes"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/api-keys/scopes')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
scopes = JSON.parse(res.body)['scopes']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/api-keys/scopes", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/api-keys/scopes"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Catálogo

Referência estática (mas actualizável sem deploy) dos métodos de pagamento, bancos e moedas suportados pela plataforma.

Métodos de pagamento

curl https://api.txenka.com/api/v1/payment-methods \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/payment-methods', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/payment-methods');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$methods = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/payment-methods",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
methods = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/payment-methods')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
methods = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/payment-methods", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/payment-methods"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

mpesa M-Pesa (Vodacom) — integração directa, requer customer_phone

emola e-Mola (Movitel) — integração directa, requer customer_phone

card Cartão — Visa e Mastercard

bank_transfer_momo Transferência via carteira móvel para conta bancária — requer customer_phone

bank_transfer_b2b Transferência da própria conta bancária do cliente — sem customer_phone

bank_transfer_atm Transferência via multibanco (ATM) — sem customer_phone

mpesa_sms M-Pesa via App Android (SMS relay) — requer customer_phone

emola_sms e-Mola via App Android (SMS relay) — requer customer_phone

mkesh_sms Mkesh (Millennium bim) via App Android — único canal disponível, requer customer_phone

Bancos suportados

curl https://api.txenka.com/api/v1/banks \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/banks', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/banks');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$banks = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/banks",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
banks = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/banks')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
banks = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/banks", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/banks"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Moedas suportadas

curl https://api.txenka.com/api/v1/currencies \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch('https://api.txenka.com/api/v1/currencies', {
  headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' },
});
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/currencies');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$currencies = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/currencies",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
)
currencies = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/currencies')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
currencies = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/currencies", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/currencies"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Estatísticas

Resumo de volume, contagens por estado, repartição por método e série diária — os mesmos dados que alimentam o dashboard, para construíres os teus próprios relatórios.

curl "https://api.txenka.com/api/v1/stats?from=2026-07-01&to=2026-07-30&days=30" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/stats?from=2026-07-01&to=2026-07-30&days=30',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const summary = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/stats?from=2026-07-01&to=2026-07-30&days=30');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$summary = json_decode(curl_exec($ch), true);

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/stats",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"from": "2026-07-01", "to": "2026-07-30", "days": 30},
)
summary = response.json()

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/stats?from=2026-07-01&to=2026-07-30&days=30')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
summary = JSON.parse(res.body)

req, _ := http.NewRequest(
    "GET",
    "https://api.txenka.com/api/v1/stats?from=2026-07-01&to=2026-07-30&days=30",
    nil,
)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/stats?from=2026-07-01&to=2026-07-30&days=30"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Logs de Pedidos

Histórico de pedidos feitos à API com esta conta — método, path, código de estado, corpo do pedido/resposta — útil para depurar uma integração sem teres de reproduzir o pedido.

curl "https://api.txenka.com/api/v1/logs?status=4xx&method=POST&limit=25" \
  -H "Authorization: Bearer txk_test_8f2a3c9d1e..."

const res = await fetch(
  'https://api.txenka.com/api/v1/logs?status=4xx&method=POST&limit=25',
  { headers: { 'Authorization': 'Bearer txk_test_8f2a3c9d1e...' } }
);
const { data } = await res.json();

$ch = curl_init('https://api.txenka.com/api/v1/logs?status=4xx&method=POST&limit=25');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer txk_test_8f2a3c9d1e...'],
]);
$logs = json_decode(curl_exec($ch), true)['data'];

import requests

response = requests.get(
    "https://api.txenka.com/api/v1/logs",
    headers={"Authorization": "Bearer txk_test_8f2a3c9d1e..."},
    params={"status": "4xx", "method": "POST", "limit": 25},
)
logs = response.json()["data"]

require 'net/http'
require 'json'

uri = URI('https://api.txenka.com/api/v1/logs?status=4xx&method=POST&limit=25')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'Bearer txk_test_8f2a3c9d1e...'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
logs = JSON.parse(res.body)['data']

req, _ := http.NewRequest("GET", "https://api.txenka.com/api/v1/logs?status=4xx&method=POST&limit=25", nil)
req.Header.Set("Authorization", "Bearer txk_test_8f2a3c9d1e...")

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

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.txenka.com/api/v1/logs?status=4xx&method=POST&limit=25"))
    .header("Authorization", "Bearer txk_test_8f2a3c9d1e...")
    .GET()
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());

Métodos de pagamento

mpesa M-Pesa — carteira móvel Vodacom

emola e-Mola — carteira móvel Movitel

card Cartão — Visa e Mastercard

bank_transfer Transferência bancária

Webhooks

Configura um endpoint em Programadores → Webhooks no dashboard para receberes uma notificação HTTP POST sempre que o estado de um pagamento mudar — sem teres de sondar a API. O secret de assinatura só é mostrado uma vez, na criação — guarda-o logo.

Eventos principais

payment_intent.succeeded

O pagamento foi confirmado com sucesso.

payment_intent.failed

O pagamento falhou ou foi recusado.

payment_intent.cancelled

O Payment Intent foi cancelado.

Erros

Erros seguem sempre o mesmo formato, com um code estável para tratares programaticamente e uma message legível.

Response

{
  "error": {
    "code": "payment_method_disabled",
    "message": "O método de pagamento 'mpesa' não está activo para esta conta."
  }
}

Precisas de ajuda a integrar?

A nossa equipa responde a dúvidas técnicas sobre a API.

Falar com a equipa