API de pagamentos para desenvolvedores

Pix, cartão e assinaturas numa API que dá gosto usar

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.

  • Pix a R$ 0,80 fixo por cobrança
  • Modo de teste na mesma URL
  • Webhooks com HMAC e retentativa
  • SDKs, CLI e MCP open source

SDKs e exemplos na linguagem do seu backend.

  • TypeScript
  • Node.js
  • Bun
  • Python
  • PHP
  • Go
  • Java
  • Ruby
  • Rust
  • Kotlin
  • Elixir
  • Swift

Comece pelo Pix

Seu primeiro Pix em uma chamada

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.

  1. Crie a chave de testeNo painel, em Integrar. A chave do modo de teste começa com abc_dev_ e não cobra ninguém.
  2. Crie o PixUm POST /v2/transparents/create com o valor em centavos em amount.
  3. Mostre o QR CodebrCodeBase64 já é a imagem do QR Code, e brCode é o Pix copia e cola.
  4. Receba a confirmaçãoSimule o pagamento e o webhook transparent.completed chega no seu endpoint.
Linguagem do exemplo
terminal
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"
    }
  }'
pix.mjs
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 cola
pix.ts · npm i @abacatepay/sdk
import { 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);
pix.py · pip install requests
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"])
pix.php
<?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"];
main.go
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_...",...},...}
}
pix.rb
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"]

200 OKa resposta, igual em toda linguagem

{
  "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

Troque a chave, não o código

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.

  • Pix simulado pela API ou pela CLI
  • Cartão de teste 4242 4242 4242 4242
  • Webhooks de teste separados dos de produção
  • devMode em toda resposta, pra não ter dúvida
Ambiente
Chave de API
abc_dev_abc_prod_••••••••••••muda
URL da API
api.abacatepay.com/v2igual
Endpoints e payloads
POST /transparents/createigual
Resposta
"devMode": truefalsemuda
Pagamento
Simulado com simulate-payment ou pela CLIDe verdade, pago no app do banco
Webhooks
Eventos de teste, também no abacatepay listenEventos reais, na URL de produção

Webhooks assinados e com retentativa

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

Eventos da API v2

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

POST /webhooks/abacatepayPagamento confirmado

{
  "id": "log_Qw8eR2tY4uI6oP1aS3dF5gH7",
  "event": "transparent.completed",
  "apiVersion": 2,
  "devMode": false,
  "data": { ... }
}

Verifique o secret e a assinatura antes de processar

Linguagem da verificação
webhook.mjs · Express
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);
webhook.py · Flask
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 "", 200
webhook.go · net/http
package 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)
}

Até 7 tentativas em cerca de 18 horas

Sem resposta 2xx, a AbacatePay tenta de novo com intervalos cada vez maiores. Quando uma tentativa recebe 2xx, as próximas são canceladas.

  1. 1ªna hora503
  2. 2ª+5 stimeout
  3. 3ª+5 min503
  4. 4ª+30 min502
  5. 5ª+2 h200 OK
  6. 6ª+5 hcancelada
  7. 7ª+10 hcancelada
  • 2xx em até 30 sentregue
  • 5xx, 408, 429 ou timeouttenta de novo
  • 410 Gonedesativa o webhook
  • Mesmo id em toda tentativaignore repetidos

AbacatePay CLI

O webhook chega no seu localhost

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.
Instalecurl -fsSL https://abacatepay.com/install.sh | sh

Ou go install github.com/AbacatePay/abacatepay-cli/cmd/abacatepay@latest. Binários pra Linux, macOS e Windows nos releases.

Feita por devs, pra devs

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.

Seu backend fica sabendo na hora

Cada mudança de status chega no seu endpoint assinada, com o mesmo id em toda tentativa.

Modo de teste = produção

Mesma URL, mesmos endpoints e mesmos payloads. Pra ir pro ar, você só troca a chave.

Retry sem cobrança dupla

Com o externalId, a mesma chamada repetida devolve o Pix pendente que já existe.

Status page pública

Disponibilidade e incidentes da API em tempo real, antes de você precisar perguntar.

llms.txt e MCP

Sua IA lê a documentação inteira pelo llms.txt e opera a conta pelo MCP.

100requisições por segundo, por loja
Limite claro

Passou disso, a API responde 429 e você tenta de novo com espera crescente.

Veja quanto você paga e quando recebe

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 especialista
Meio de pagamentoTaxaRecebimento

Pix

PixR$ 0,80 por transaçãoNa hora

Boleto com Pix

Pago pelo PixR$ 0,80Na hora
Pago como boletoR$ 2,50Em até 3 dias úteis

Cartão de débito

Débito2,5% + R$ 0,60No dia seguinte

Cartão de crédito

1x5,42% + R$ 0,60No dia seguinte, valor integral
2x6,92% + R$ 0,60No dia seguinte, valor integral
3x7,91% + R$ 0,60No dia seguinte, valor integral
4x8,91% + R$ 0,60No dia seguinte, valor integral
5x9,90% + R$ 0,60No dia seguinte, valor integral
6x10,90% + R$ 0,60No dia seguinte, valor integral
7x12,39% + R$ 0,60No dia seguinte, valor integral
8x13,39% + R$ 0,60No dia seguinte, valor integral
9x14,38% + R$ 0,60No dia seguinte, valor integral
10x15,38% + R$ 0,60No dia seguinte, valor integral
11x16,37% + R$ 0,60No dia seguinte, valor integral
12x17,37% + R$ 0,60No dia seguinte, valor integral

Sem custo fixo

MensalidadeR$ 0Não se aplica
AdesãoR$ 0Não se aplica

Exemplo: o amount: 10000 do código, uma venda de R$ 100,00

  • Pix de R$ 100,00

    R$ 99,20na hora, taxa fixa de R$ 0,80
  • A 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 seguinte

A API, os SDKs, a CLI e o modo de teste não custam nada: você paga só pelas cobranças pagas.

Suporte com resposta em até 20 minutos

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.

  • Resposta em até 20 minutos, das 9h às 19h
  • Grupo de WhatsApp com decisores para operações maiores
  • Atendimento feito por quem conhece a integração pela API
Falar com um especialista
Time da AbacatePay no escritório

Dúvidas técnicas sobre a API

As perguntas que mais chegam de quem está integrando a AbacatePay.

Quais linguagens têm SDK oficial da 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.

Como funciona o ambiente de desenvolvimento (sandbox)?

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.

A API tem limite de requisições?

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.

Como funcionam os webhooks?

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.

Como testo o webhook no meu computador?

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.

A AbacatePay tem MCP Server para AI agents?

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

Quanto custa usar a API?

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.

Preciso de CNPJ?

Sim. Por enquanto a AbacatePay é só pra CNPJ. MEI serve.

A integração é simples?

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.

Qual a diferença entre a API Pix e o checkout?

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

Como evito cobrança duplicada se a requisição falhar?

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.

Ler a documentação

API, SDKs, CLI e modo de teste sem custo.

Build. Ship.
Get paid.

Crie a conta grátis, pegue a chave de teste e faça o primeiro Pix ainda hoje.

Fale com o time

Sem mensalidade. Aprovação não leva semanas.

Ilustração renascentista com anjos e um abacate numa concha