Seu backend fica sabendo na hora
Cada mudança de status chega no seu endpoint assinada, com o mesmo id em toda tentativa.
API de pagamentos para desenvolvedores
Uma API baseada em intenção, SDKs abertos, webhooks assinados e uma CLI que traz o evento pro seu localhost. Feita por devs pra devs, com o modo de teste igual à produção.
Comece pelo Pix
Um POST com o valor e a API devolve o QR Code e o copia e cola. Use o SDK ou o cliente HTTP da sua linguagem: a rota diz o que faz e a resposta vem em JSON.
abc_dev_ e não cobra ninguém.POST /v2/transparents/create com o valor em centavos em amount.brCodeBase64 já é a imagem do QR Code, e brCode é o Pix copia e cola.transparent.completed chega no seu endpoint.curl -X POST https://api.abacatepay.com/v2/transparents/create \
-H "Authorization: Bearer $ABACATEPAY_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"method": "PIX",
"data": {
"amount": 10000,
"description": "Pedido #1042",
"externalId": "pedido-1042"
}
}'const url = "https://api.abacatepay.com/v2/transparents/create";
const res = await fetch(url, {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.ABACATEPAY_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
method: "PIX",
data: {
amount: 10000,
description: "Pedido #1042",
externalId: "pedido-1042",
},
}),
});
const { data, error } = await res.json();
if (error) throw new Error(error);
console.log(data.id, data.brCode); // pix_char_... e o Pix copia e colaimport { AbacatePay } from "@abacatepay/sdk";
const abacate = AbacatePay({ secret: process.env.ABACATEPAY_API_KEY });
const pix = await abacate.pix.create({
amount: 10000,
description: "Pedido #1042",
externalId: "pedido-1042",
});
if (!pix.success) throw new Error(pix.error);
console.log(pix.data.id, pix.data.brCode);import os
import requests
res = requests.post(
"https://api.abacatepay.com/v2/transparents/create",
headers={"Authorization": f"Bearer {os.environ['ABACATEPAY_API_KEY']}"},
json={
"method": "PIX",
"data": {
"amount": 10000,
"description": "Pedido #1042",
"externalId": "pedido-1042",
},
},
)
body = res.json()
if body["error"]:
raise Exception(body["error"])
print(body["data"]["id"], body["data"]["brCode"])<?php
$ch = curl_init("https://api.abacatepay.com/v2/transparents/create");
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
"Authorization: Bearer " . getenv("ABACATEPAY_API_KEY"),
"Content-Type: application/json",
],
CURLOPT_POSTFIELDS => json_encode([
"method" => "PIX",
"data" => [
"amount" => 10000,
"description" => "Pedido #1042",
"externalId" => "pedido-1042",
],
]),
]);
$body = json_decode(curl_exec($ch), true);
if ($body["error"]) {
throw new Exception($body["error"]);
}
echo $body["data"]["id"], PHP_EOL, $body["data"]["brCode"];package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
)
func main() {
body, _ := json.Marshal(map[string]any{
"method": "PIX",
"data": map[string]any{
"amount": 10000,
"description": "Pedido #1042",
"externalId": "pedido-1042",
},
})
url := "https://api.abacatepay.com/v2/transparents/create"
req, _ := http.NewRequest("POST", url, bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+os.Getenv("ABACATEPAY_API_KEY"))
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer res.Body.Close()
out, _ := io.ReadAll(res.Body)
fmt.Println(string(out)) // {"data":{"id":"pix_char_...",...},...}
}require "net/http"
require "json"
key = ENV.fetch("ABACATEPAY_API_KEY")
body = {
method: "PIX",
data: {
amount: 10000,
description: "Pedido #1042",
externalId: "pedido-1042"
}
}
res = Net::HTTP.post(
URI("https://api.abacatepay.com/v2/transparents/create"),
body.to_json,
"Authorization" => "Bearer #{key}",
"Content-Type" => "application/json"
)
result = JSON.parse(res.body)
raise result["error"] if result["error"]
puts result["data"]["id"], result["data"]["brCode"]{
"data": {
"id": "pix_char_mXq2Lk7vB9nR4sT8yW1zC6dF",
"amount": 10000,
"status": "PENDING",
"devMode": true,
"brCode": "00020101021226950014br.gov.bcb.pix2573...",
"brCodeBase64": "data:image/png;base64,iVBORw0KG...",
"platformFee": 80,
"expiresAt": "2026-10-29T19:38:28.573Z"
},
"success": true,
"error": null
}Dev mode = prod mode
O modo de teste usa a mesma URL, os mesmos endpoints e os mesmos payloads da produção. Você integra com a chave de teste e vai pro ar trocando uma variável de ambiente.
abc_dev_abc_prod_••••••••••••mudaapi.abacatepay.com/v2igualPOST /transparents/createigual"devMode": truefalsemudasimulate-payment ou pela CLIDe verdade, pago no app do bancoabacatepay listenEventos reais, na URL de produçãoA cada mudança de status, um POST no seu endpoint com o secret na URL e a assinatura HMAC-SHA256 no header X-Webhook-Signature. Se o seu servidor cair, o evento espera por ele.
Toque num evento pra ver o envelope que chega.
Checkout transparente Pix, cartão e boleto
Checkout e link de pagamento página pronta
Assinaturas cartão e Pix Automático
Saques e transferências dinheiro saindo
{
"id": "log_Qw8eR2tY4uI6oP1aS3dF5gH7",
"event": "transparent.completed",
"apiVersion": 2,
"devMode": false,
"data": { ... }
}Verifique o secret e a assinatura antes de processar
import crypto from "node:crypto";
import express from "express";
// Chave pública: docs.abacatepay.com/pages/webhooks/security
const PUBLIC_KEY = process.env.ABACATEPAY_PUBLIC_KEY;
const app = express();
app.post(
"/webhooks/abacatepay",
express.raw({ type: "application/json" }),
(req, res) => {
if (req.query.webhookSecret !== process.env.WEBHOOK_SECRET) {
return res.sendStatus(401);
}
const expected = crypto
.createHmac("sha256", PUBLIC_KEY)
.update(req.body)
.digest("base64");
const a = Buffer.from(expected);
const b = Buffer.from(req.get("X-Webhook-Signature") ?? "");
if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
return res.sendStatus(401);
}
const { id, event, data } = JSON.parse(req.body);
if (event === "transparent.completed") {
// libere o pedido; o id se repete nas retentativas
}
res.sendStatus(200);
},
);
app.listen(3000);import base64, hashlib, hmac, os
from flask import Flask, request
# Chave pública: docs.abacatepay.com/pages/webhooks/security
PUBLIC_KEY = os.environ["ABACATEPAY_PUBLIC_KEY"].encode()
app = Flask(__name__)
@app.post("/webhooks/abacatepay")
def webhook():
if request.args.get("webhookSecret") != os.environ["WEBHOOK_SECRET"]:
return "", 401
body = request.get_data()
digest = hmac.new(PUBLIC_KEY, body, hashlib.sha256).digest()
expected = base64.b64encode(digest).decode()
received = request.headers.get("X-Webhook-Signature", "")
if not hmac.compare_digest(expected, received):
return "", 401
event = request.get_json()
if event["event"] == "transparent.completed":
pass # libere o pedido (o id se repete nas retentativas)
return "", 200package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"io"
"net/http"
"os"
)
// Chave pública: docs.abacatepay.com/pages/webhooks/security
var publicKey = []byte(os.Getenv("ABACATEPAY_PUBLIC_KEY"))
func webhook(w http.ResponseWriter, r *http.Request) {
if r.URL.Query().Get("webhookSecret") != os.Getenv("WEBHOOK_SECRET") {
w.WriteHeader(http.StatusUnauthorized)
return
}
body, _ := io.ReadAll(r.Body)
mac := hmac.New(sha256.New, publicKey)
mac.Write(body)
expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
received := r.Header.Get("X-Webhook-Signature")
if !hmac.Equal([]byte(expected), []byte(received)) {
w.WriteHeader(http.StatusUnauthorized)
return
}
var event map[string]any
json.Unmarshal(body, &event)
if event["event"] == "transparent.completed" {
// libere o pedido (o id se repete nas retentativas)
}
w.WriteHeader(http.StatusOK)
}
func main() {
http.HandleFunc("POST /webhooks/abacatepay", webhook)
http.ListenAndServe(":3000", nil)
}Sem resposta 2xx, a AbacatePay tenta de novo com intervalos cada vez maiores. Quando uma tentativa recebe 2xx, as próximas são canceladas.
AbacatePay CLI
A CLI oficial, em Go e open source, traz os eventos do modo de teste pra sua máquina. Sem túnel e sem deploy pra testar o fluxo inteiro.
abacatepay loginAbre o navegador pra você aprovar o acesso da CLI na sua conta.abacatepay listen --forward-to http://localhost:3000/webhooks/abacatepayRecebe os webhooks do modo de teste e repassa pro seu servidor, com a mesma assinatura da produção.abacatepay payments simulate <id>Paga um Pix de teste sem abrir o app do banco.curl -fsSL https://abacatepay.com/install.sh | shOu go install github.com/AbacatePay/abacatepay-cli/cmd/abacatepay@latest. Binários pra Linux, macOS e Windows nos releases.
Os detalhes que a gente queria ter encontrado quando integrava pagamento: teste igual à produção, retry seguro e limite claro. Depois de receber, automatize o saque via API. Se ainda está escolhendo provedor, veja o comparativo de APIs de pagamento.
Cada mudança de status chega no seu endpoint assinada, com o mesmo id em toda tentativa.
Mesma URL, mesmos endpoints e mesmos payloads. Pra ir pro ar, você só troca a chave.
Com o externalId, a mesma chamada repetida devolve o Pix pendente que já existe.
Disponibilidade e incidentes da API em tempo real, antes de você precisar perguntar.
Sua IA lê a documentação inteira pelo llms.txt e opera a conta pelo MCP.
Passou disso, a API responde 429 e você tenta de novo com espera crescente.
A tabela mostra a taxa por transação e o prazo de recebimento de cada meio de pagamento. Não há mensalidade nem taxa de adesão.
Também dá pra receber as vendas no cartão em 7, 15 ou 30 dias, com taxa menor.
Ver a tabela por prazo →Falar com um especialistaPix
Boleto com Pix
Cartão de débito
Cartão de crédito
Sem custo fixo
Pix de R$ 100,00
R$ 99,20na hora, taxa fixa de R$ 0,80A mesma venda no cartão à vista
R$ 93,98no dia seguinte (5,42% + R$ 0,60)A mesma venda em 12x no cartão
R$ 82,03o valor inteiro no dia seguinteA API, os SDKs, a CLI e o modo de teste não custam nada: você paga só pelas cobranças pagas.
Use o que encaixa no seu stack: SDK, adaptador do framework, CLI, coleção de requisições ou a sua IA.
Node.js com TypeScript e Ruby na API v2, e SDKs abertos em Python, PHP, Go, Java, Rust, Kotlin e Elixir.
Ver os SDKs →Webhook pronto no Express, Fastify, Hono, Elysia e Supabase, mais o SDK, os tipos, o Zod e o TypeBox.
Ver o ecossistema →Login pelo navegador, webhooks do modo de teste no localhost e Pix simulado pelo terminal.
Instalar a CLI →O Claude, o Cursor e outros agentes criam cobranças pelo MCP, e o llms.txt ensina a API pra sua IA.
Integrar com IA →As requisições da API em arquivos .http versionados, pra rodar direto do editor.
Ver a coleção →Cobranças e eventos da AbacatePay nos seus fluxos do n8n, sem escrever código.
Ver o nó →SDKs, CLI, MCP, plugin de ESLint que barra chave no código e até o tema do VS Code. Leia, abra issue, mande PR.
Ver o open source →Páginas de cada recurso da API — o que faz e para onde ir. A referência de endpoints continua na documentação.
Crie um checkout hospedado e receba a URL pronta para redirecionar o cliente.
API de checkout →Gere um link reutilizável de cobrança para compartilhar em canais que você já usa.
API de links de pagamento →Cadastre o cliente uma vez, evite duplicar CPF/CNPJ e pré-preencha o checkout.
API de clientes →Cadastre o catálogo uma vez e reutilize em checkouts, links e assinaturas.
API de produtos →Configure cobranças recorrentes e cancele ou troque o plano pela API.
API de assinaturas →Crie cupons percentuais ou de valor fixo e controle uso e validade.
API de cupons →Transfira o saldo da conta para uma chave Pix do mesmo CNPJ.
API de saques →Envie Pix para terceiros (clientes, fornecedores, parceiros) pela API.
API de envio de Pix →Cadastre URLs para receber eventos assinados, com retry automático.
webhooks de pagamento →Consulte nome e saldos da loja (disponível, pendente e bloqueado).
API de dados da loja →Consulte MRR e receita por um token de leitura, sem usar a chave principal.
API Public MRR →Gere QR Code Pix (imagem e copia e cola) e confirme o pagamento por webhook.
API Pix e QR Code →Painel e métricas públicas para cuidar da base, do catálogo e da receita.
Cadastro único por CPF/CNPJ, checkout pré-preenchido e histórico no painel.
Gestão de clientes →Catálogo reutilizável em checkouts, links e assinaturas.
Produtos e catálogo →Faturamento, ticket médio, conversão, MRR e churn no painel.
Analytics de pagamentos →Conecte o Trust MRR com o Public MRR e consulte métricas com token de leitura.
Trust MRR e métricas públicas →Changelog aberto, comunidade no Discord, status em tempo real e o código no GitHub. Você sabe o que mudou antes de precisar perguntar.
Cada mudança na API e nos webhooks, com a data e o que muda pra quem já integrou.
Tire dúvida com outros devs e com quem faz a API, mostre o que você construiu e peça feature.
Entrar no Discord →API, checkout e webhooks com o histórico de disponibilidade e os incidentes em tempo real.
Ver a status page →SDKs, CLI, MCP e tipos abertos. Abra uma issue, mande um PR ou só leia o código.
O atendimento funciona das 9h às 19h, com tempo de resposta de até 20 minutos. Operações com volume maior também contam com um grupo de WhatsApp com os decisores da AbacatePay.

Agentes de IA, open source, SaaS e apps: a mesma API e as mesmas taxas, com o que cada projeto precisa.
As perguntas que mais chegam de quem está integrando a AbacatePay.
Node.js com TypeScript (@abacatepay/sdk) e Ruby já usam a API v2. Python, PHP, Go, Java, Rust, Kotlin e Elixir também têm SDK aberto no GitHub, ainda na API v1, e o de Swift está em desenvolvimento. Como a API recebe e responde JSON por HTTP, qualquer linguagem com um cliente HTTP integra: os exemplos desta página usam só o cliente de cada uma.
O modo de teste (Dev mode) usa a mesma URL, os mesmos endpoints e os mesmos payloads da produção. O que muda é a chave de API: a que começa com abc_dev_ simula as cobranças, e a de produção cobra de verdade. Pra ir pro ar, você troca a chave e o código fica igual. No teste, o Pix é pago com POST /v2/transparents/simulate-payment ou pela CLI, e o cartão 4242 4242 4242 4242 é aprovado.
Tem: 100 requisições por segundo por loja. Passou disso, a API responde 429 e é só tentar de novo com espera crescente. Se a sua operação precisa de mais, fale com o nosso time.
Cadastre a URL no painel ou pela API. A cada evento (transparent.completed, checkout.completed, subscription.renewed e outros), a AbacatePay faz um POST com o JSON do evento, com o secret na URL e a assinatura HMAC-SHA256 no header X-Webhook-Signature. Sem resposta 2xx em 30 segundos, ela tenta de novo: até 7 tentativas em cerca de 18 horas, sempre com o mesmo id, pra você ignorar repetidos.
Com a CLI da AbacatePay: abacatepay listen --forward-to http://localhost:3000/webhooks/abacatepay recebe os eventos do modo de teste e repassa pro seu servidor local, assinados como na produção. Em outro terminal, abacatepay payments simulate <id> paga o Pix de teste.
Tem. Com o MCP da AbacatePay (mcp.abacatepay.com/mcp), o Claude, o Cursor e outros agentes criam cobranças, enviam Pix e consultam relatórios da sua conta. E o llms.txt da documentação ensina a API inteira pra sua IA integrar com você.
A API, os SDKs, a CLI e o modo de teste não custam nada. Você paga por cobrança: R$ 0,80 fixo no Pix e, no cartão (ativado sob consulta), de 5,42% + R$ 0,60 à vista a 17,37% + R$ 0,60 em 12x, com o valor integral no dia seguinte. Sem mensalidade e sem adesão.
Sim. Por enquanto a AbacatePay é só pra CNPJ. MEI serve.
Sim. O primeiro Pix sai com uma chamada HTTP e a chave de teste que começa com abc_dev_. A mesma URL, os mesmos endpoints e os mesmos payloads valem na produção: pra ir ao ar, você troca a chave.
A API Pix (/api-pix) é pra quem quer o controle no próprio código: você cria a cobrança, renderiza o QR e confirma por webhook. O checkout (/checkout) é a tela transparente pronta, com a sua marca, sem montar o front de pagamento. Se ainda está comparando provedores, veja o comparativo de APIs de pagamento no Brasil (/blog/melhores-apis-de-pagamento-brasil).
Passe um externalId estável na criação. Se a mesma chamada for repetida, a API devolve o Pix pendente que já existe em vez de criar outro.
API, SDKs, CLI e modo de teste sem custo.
Crie a conta grátis, pegue a chave de teste e faça o primeiro Pix ainda hoje.
Sem mensalidade. Aprovação não leva semanas.
