Skip to main content
O split de pagamento permite repartir o valor de um único pagamento entre vários recebedores (recipients) — por exemplo, plataforma, vendedor e afiliado. A divisão é definida no array payment.split[] ao Criar Pedido ou Criar Assinatura, e a Autorizou liquida cada parte para o recebedor correto.
Antes de fazer split, cadastre os recebedores em Criar Recebedor. Cadastros incompletos aparecem em Recebedores Incompletos e não recebem até serem regularizados.

​
Como funciona

​
Parâmetros do split

Cada item de payment.split[] descreve a parte de um recebedor:
​
integer
required
Identificador do recebedor que receberá esta parte.
​
integer
required
Valor destinado ao recebedor, em centavos (quando type = flat) ou o valor base do cálculo. Cada parte não pode ser maior que payment.amount, e a soma das partes deve respeitar o total do pagamento.
​
string
required
Tipo da divisão. Valores possíveis:
  • flat — valor fixo em centavos.
  • percentage — percentual do valor do pagamento.
​
boolean
required
Se true, este recebedor arca (proporcionalmente) com a taxa de processamento do pagamento.
​
boolean
required
Se true, este recebedor arca com o restante das taxas que não foram cobertas pelos demais.
​
boolean
required
Se true, este recebedor é responsável (liable) em caso de chargeback — o valor é debitado dele na disputa.
​
integer
Valor de juros (centavos) atribuído a este recebedor, quando aplicável.
Em assinaturas, o split também aceita payment.split[].percentage_amount (percentual) para calcular a parte de cada recebedor a cada ciclo.

​
Exemplo

​
Regras importantes

Soma consistente

A soma das partes deve fechar com payment.amount (considerando taxas e juros configurados).

Responsabilidade

Use is_liable para definir quem absorve o prejuízo em um chargeback.

Taxas

allow_charge_processing_fee / allow_charge_remainder_fee controlam quem paga as taxas — evite deixar taxas sem responsável.

Recebedores aptos

Só recebedores com cadastro completo recebem o repasse.

​
Split configurado (sem enviar split[])

Além do split ad-hoc acima (você envia split[] na venda), a conta pode ter um split configurado: uma regra de divisão cadastrada uma vez que a plataforma aplica automaticamente — mesmo que a venda não traga split[] nenhum. A plataforma escolhe qual regra aplicar por uma cascata, do mais específico ao mais genérico:
  1. split[] no payload — se você enviou, ele prevalece (sobrepõe a config).
  2. Canal — se o canal da venda (API, link, assinatura, POS) tem config própria, usa ela.
  3. Grupo — senão, se o dono está num grupo de recebedores com config, usa a do grupo.
  4. Global da conta — senão, a config padrão da conta.
  5. Nenhuma — o lojista fica com o valor inteiro.
O que isso significa para você (parceiro): uma venda criada por API sem split[] é do canal API e cai na config global da conta. Ou seja — se a conta tem split configurado, a sua venda nasce dividida sem nada no payload de entrada. A divisão que de fato aconteceu vem no campo split do retorno — veja Split realizado no retorno.
Para ver a regra que se aplica às suas vendas, ou simular a divisão de um valor antes de vender, use GET /split-configs/resolved e POST /split-configs/simulate — veja Visibilidade pós-venda.
Os recebedores podem ter painel próprio (login independente) para acompanhar os repasses. A gestão das configurações de split é feita no painel, não por API.

​
Split realizado no retorno (o que você recebe)

Não importa como a divisão foi decidida — enviada por você (split[]) ou resolvida pela config da conta —, a Autorizou devolve a divisão que de fato aconteceu no campo split. É a fotografia gravada no momento da venda: quem recebeu quanto, no centavo. Esse bloco aparece em todas as representações do pagamento:
  • na resposta da criação da cobrança (retorno síncrono);
  • no GET /payments/{identifier};
  • em todos os webhooks do pagamento (payment.created, payment.authorized, reversos…).
O split do retorno é diferente do split[] que você envia. No envio você usa recipient_id (o id do recebedor) e parâmetros de cálculo (type, allow_charge_*). No retorno você recebe a divisão já calculada, com o recebedor identificado por uuid e o valor final em centavos.
Cada item da lista é uma fatia:
​
object
O recebedor da fatia (uuid e name). É null quando a fatia é do próprio lojista da chave (você fica com esse pedaço).
​
integer
Valor da fatia, em centavos.
​
integer
Parte dos juros (centavos) atribuída a esta fatia, quando aplicável.
​
integer
Percentual (0–100) aplicado no momento da venda. Snapshot imutável; pode ser null em vendas sem percentual registrado.
​
boolean
Se esta fatia absorve o prejuízo num chargeback — o mesmo boolean que você envia no split[] da criação, ecoado com o mesmo nome.
O bloco é condicional: só vem quando a venda foi dividida. A ordem das fatias é estável (ordem de criação), e a soma fecha com payment.amount (considerando taxas e juros) — você pode conferir a conservação no centavo.

​
Conciliação e repasse

Concilie pelo split do retorno: some as fatias, amarre cada recipient.uuid ao seu cadastro e reflita o resultado no seu sistema. Como a divisão é fotografada por venda, mudanças futuras de regra não alteram vendas passadas — o split do retorno é a fonte da verdade histórica (não a config atual). Depois da liquidação, acompanhe os repasses — veja Conciliação.