> ## Documentation Index
> Fetch the complete documentation index at: https://docs.autorizou.com.br/llms.txt
> Use this file to discover all available pages before exploring further.

# Split de Pagamento

> Divida automaticamente o valor de um pagamento entre múltiplos recebedores

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](/api-reference/charges/orders/create-order) ou
[Criar Assinatura](/api-reference/subscriptions/create-subscription), e a Autorizou
liquida cada parte para o recebedor correto.

<Note>
  Antes de fazer split, cadastre os recebedores em
  [Criar Recebedor](/api-reference/recipients/create-recipient). Cadastros
  incompletos aparecem em
  [Recebedores Incompletos](/api-reference/recipients/incomplete-recipients) e
  **não recebem** até serem regularizados.
</Note>

## Como funciona

```mermaid theme={null}
flowchart LR
    A[Pagamento R$ 1.000] --> S{Split}
    S -->|R$ 800| V[Vendedor]
    S -->|R$ 150| P[Plataforma]
    S -->|R$ 50| AF[Afiliado]
```

## Parâmetros do split

Cada item de `payment.split[]` descreve a parte de um recebedor:

<ParamField body="payment.split[].recipient_id" type="integer" required>
  Identificador do recebedor que receberá esta parte.
</ParamField>

<ParamField body="payment.split[].amount" type="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.
</ParamField>

<ParamField body="payment.split[].type" type="string" required>
  Tipo da divisão. Valores possíveis:

  * `flat` — valor fixo em centavos.
  * `percentage` — percentual do valor do pagamento.
</ParamField>

<ParamField body="payment.split[].allow_charge_processing_fee" type="boolean" required>
  Se `true`, este recebedor arca (proporcionalmente) com a **taxa de
  processamento** do pagamento.
</ParamField>

<ParamField body="payment.split[].allow_charge_remainder_fee" type="boolean" required>
  Se `true`, este recebedor arca com o **restante das taxas** que não foram
  cobertas pelos demais.
</ParamField>

<ParamField body="payment.split[].is_liable" type="boolean" required>
  Se `true`, este recebedor é **responsável** (liable) em caso de chargeback —
  o valor é debitado dele na disputa.
</ParamField>

<ParamField body="payment.split[].interest_amount" type="integer">
  Valor de juros (centavos) atribuído a este recebedor, quando aplicável.
</ParamField>

<Note>
  Em **assinaturas**, o split também aceita `payment.split[].percentage_amount`
  (percentual) para calcular a parte de cada recebedor a cada ciclo.
</Note>

## Exemplo

```json theme={null}
{
  "payment": {
    "amount": 100000,
    "payment_method": "credit_card",
    "installments": 1,
    "credit_card": { "id": 42, "statement_descriptor": "PLATAFORMA", "capture": true, "processing_model": "..." },
    "split": [
      {
        "recipient_id": 1001,
        "amount": 80000,
        "type": "flat",
        "allow_charge_processing_fee": true,
        "allow_charge_remainder_fee": true,
        "is_liable": true
      },
      {
        "recipient_id": 1002,
        "amount": 15000,
        "type": "flat",
        "allow_charge_processing_fee": false,
        "allow_charge_remainder_fee": false,
        "is_liable": false
      },
      {
        "recipient_id": 1003,
        "amount": 5000,
        "type": "flat",
        "allow_charge_processing_fee": false,
        "allow_charge_remainder_fee": false,
        "is_liable": false
      }
    ]
  }
}
```

## Regras importantes

<CardGroup cols={2}>
  <Card title="Soma consistente" icon="equals">
    A soma das partes deve fechar com `payment.amount` (considerando taxas e
    juros configurados).
  </Card>

  <Card title="Responsabilidade" icon="scale-balanced">
    Use `is_liable` para definir quem absorve o prejuízo em um chargeback.
  </Card>

  <Card title="Taxas" icon="percent">
    `allow_charge_processing_fee` / `allow_charge_remainder_fee` controlam quem
    paga as taxas — evite deixar taxas sem responsável.
  </Card>

  <Card title="Recebedores aptos" icon="user-check">
    Só recebedores com cadastro completo recebem o repasse.
  </Card>
</CardGroup>

## 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](#split-realizado-no-retorno-o-que-você-recebe).

<Tip>
  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](/partner-visibility).
</Tip>

<Note>
  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.
</Note>

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

<Note>
  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.
</Note>

Cada item da lista é uma fatia:

<ResponseField name="split[].recipient" type="object">
  O recebedor da fatia (`uuid` e `name`). É **`null`** quando a fatia é do **próprio lojista** da
  chave (você fica com esse pedaço).
</ResponseField>

<ResponseField name="split[].amount" type="integer">
  Valor da fatia, em **centavos**.
</ResponseField>

<ResponseField name="split[].interest_amount" type="integer">
  Parte dos juros (centavos) atribuída a esta fatia, quando aplicável.
</ResponseField>

<ResponseField name="split[].percentage" type="integer">
  Percentual (0–100) aplicado no momento da venda. Snapshot imutável; pode ser `null` em vendas sem
  percentual registrado.
</ResponseField>

<ResponseField name="split[].is_liable" type="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.
</ResponseField>

```json theme={null}
{
  "split": [
    {
      "recipient": { "uuid": "9b2c1f7a-3e4d-4a8b-9c1d-2f3e4a5b6c7d", "name": "Clínica Osasco" },
      "amount": 8500,
      "interest_amount": 0,
      "percentage": 85,
      "is_liable": true
    },
    {
      "recipient": null,
      "amount": 1500,
      "interest_amount": 0,
      "percentage": 15,
      "is_liable": false
    }
  ]
}
```

<Info>
  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.
</Info>

## 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](/casos-uso/conciliacao).