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

# Credenciais e ambientes

> Gere suas chaves, entenda a diferença entre testes e produção e faça a primeira chamada autenticada.

Toda requisição à API da Finvia precisa de uma **chave secreta**. É com ela que a API sabe qual empresa está chamando, quais permissões ela tem e se a operação é de teste ou de produção.

> [!NOTE]
>
> **Para o negócio:** a chave secreta dá acesso a cobranças, saldos e dados de clientes. Ela deve ficar só com o time técnico responsável pela integração, guardada no servidor, e nunca deve circular por e-mail, chat ou planilha. Se alguém de fora tiver acesso a ela, peça a troca ao suporte da Finvia imediatamente.

## Tipos de chave

| Chave | Prefixo | Onde usar | Para que serve |
| - | - | - | - |
| Chave secreta de produção | `sk_` | Somente no servidor | Todas as operações reais: cobranças, assinaturas, saques |
| Chave secreta de teste | `sk_test_` | Somente no servidor | Cobranças simuladas no ambiente de testes. Não faz saques |
| Chave pública de produção | `pk_` | Navegador ou aplicativo | Fluxos que rodam no front-end, como Apple Pay e o SDK de 3D Secure |
| Chave pública de teste | `pk_test_` | Navegador ou aplicativo | Os mesmos fluxos, no ambiente de testes |

> [!WARNING]
>
> A chave **secreta** (`sk_`) nunca pode aparecer em código que roda no navegador, no aplicativo do cliente ou em repositórios. A chave **pública** (`pk_`) foi feita para o front-end e só é aceita nas rotas que pedem por ela.

### Onde a chave pública entra

A chave pública vai no lugar do usuário do HTTP Basic, do mesmo jeito que a secreta, mas em chamadas feitas a partir do navegador:

| Fluxo | Onde a `pk_` é usada |
| - | - |
| Apple Pay | Na validação da sessão (`POST /v1/apple-pay/validate-merchant`), chamada pelo front-end. Veja [Apple Pay](https://docs.fastpaybrasil.com/guias/cobrancas/apple-pay.md) |
| 3D Secure | Nas rotas de autenticação 3DS (`/v1/three-ds/*`), na retomada da cobrança (`POST /v1/charges/{id}/resume-3ds`) e na inicialização do SDK de segurança (`publicKey`). Veja [3D Secure](https://docs.fastpaybrasil.com/guias/3d-secure/visao-geral.md) |
| Subcontas do Connect | Cada subconta tem o próprio par `sk_`/`pk_`, que a conta master consulta em [Chaves de API da subconta](https://docs.fastpaybrasil.com/referencia/fast-connect/chaves-de-api.md) |

A chave pública não cria cobranças. Ela pode ficar no HTML da página ou no aplicativo, porque só é aceita nesses fluxos. A conta precisa estar ativa para a `pk_` funcionar.

## Ambientes de teste e produção

A Finvia usa o **mesmo endereço** para testes (sandbox) e produção. O ambiente é definido pela chave enviada na requisição: com a chave de teste (Modo Teste), as cobranças são simuladas; com a chave de produção, as transações são reais.

| Ambiente | URL base | Quando usar |
| - | - | - |
| Produção | `https://api-global.fastpaybrasil.com` | Transações reais com clientes reais |
| Sandbox | `https://api-global.fastpaybrasil.com` | Desenvolvimento e homologação, com a chave de teste |

Os outros endereços que você vai usar:

| Para quê | Endereço |
| - | - |
| Painel | `https://app.finvia.com.br` |
| Site | `https://www.finvia.com.br` |
| Documentação | `https://docs.fastpaybrasil.com` |
| SDK de 3D Secure via CDN | `https://js.fastpaybrasil.com/security-sdk.min.js` |

A sua aplicação precisa de uma única variável de configuração para a URL e de uma variável para a chave. Trocar de ambiente é trocar a chave.

```bash theme={null}
export FINVIA_API_URL="https://api-global.fastpaybrasil.com"
export FINVIA_API_KEY="sua_chave_secreta"
```

A chave pública de teste (`pk_test_`) também coloca as chamadas do front-end em modo de teste. A exceção é a validação de sessão do Apple Pay: ela sempre vai ao provedor real, porque a janela de pagamento do Safari só abre com uma sessão real. A cobrança Apple Pay criada depois, com a chave de teste, é simulada normalmente.

### O que é simulado no Modo Teste

O desenho abaixo mostra como a chave define o ambiente e quais operações continuam reais mesmo com a chave de teste.

```mermaid placement="top-right" className="finvia-diagrama" theme={null}
%%{init: {"theme": "base", "fontFamily": "Inter, sans-serif", "themeVariables": {"fontFamily": "Inter, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#EAF3FF", "primaryBorderColor": "#017AFF", "primaryTextColor": "#070D15", "secondaryColor": "#F3F5F8", "tertiaryColor": "#FFFFFF", "lineColor": "#5B6B82", "textColor": "#070D15", "edgeLabelBackground": "#FFFFFF", "clusterBkg": "#F7F9FC", "clusterBorder": "#D5DCE6", "actorBkg": "#FFFFFF", "actorBorder": "#98A2B3", "actorTextColor": "#070D15", "actorLineColor": "#B8C2D1", "signalTextColor": "#070D15", "labelBoxBkgColor": "#EAF3FF", "labelBoxBorderColor": "#017AFF", "labelTextColor": "#003A7A", "loopTextColor": "#070D15", "noteBkgColor": "#FFF6E5", "noteBorderColor": "#F0B44C", "noteTextColor": "#5C3D00", "activationBkgColor": "#EAF3FF", "activationBorderColor": "#017AFF", "sequenceNumberColor": "#FFFFFF", "signalColor": "#5B6B82"}, "flowchart": {"curve": "basis", "nodeSpacing": 45, "rankSpacing": 55, "padding": 18}, "sequence": {"mirrorActors": false, "showSequenceNumbers": true, "actorMargin": 60, "messageMargin": 38, "boxMargin": 10, "noteMargin": 12, "wrap": true}}}%%
flowchart TB
    R(["Requisição à API<br/>mesma URL nos dois"]):::neutro
    Q{"Qual chave<br/>foi enviada?"}:::decisao
    TEST["Modo Teste<br/>sk_test_"]:::alerta
    PROD["Produção<br/>sk_"]:::finvia
    T1["Cobranças<br/>simuladas, inclusive com<br/>cartão salvo e Apple Pay"]:::ok
    T2["Cadastro de cartão<br/>registro real no cofre,<br/>sem cobrança"]:::alerta
    T3["Assinaturas<br/>cobram de verdade,<br/>inclusive o R$ 1,00 do trial"]:::erro
    T4["Saques<br/>recusados com 403"]:::erro
    REAL["Todas as operações<br/>são reais"]:::ok
    R --> Q
    Q -->|"sk_test_"| TEST
    Q -->|"sk_"| PROD
    TEST --> T1
    TEST --> T2
    TEST --> T3
    TEST --> T4
    PROD --> REAL
    T2 -.->|"mesmo cofre:<br/>o cardTokenId cobra<br/>de verdade com sk_"| PROD
    classDef alerta fill:#FFF6E5,stroke:#B45309,stroke-width:1.5px,color:#5C3D00
    classDef decisao fill:#FFFFFF,stroke:#017AFF,stroke-width:2px,color:#070D15
    classDef erro fill:#FDECEC,stroke:#B42318,stroke-width:1.5px,color:#7A1209
    classDef finvia fill:#017AFF,stroke:#0060CC,stroke-width:1.5px,color:#FFFFFF,font-weight:600
    classDef neutro fill:#FFFFFF,stroke:#B8C2D1,stroke-width:1.5px,color:#344054
    classDef ok fill:#E8F7EE,stroke:#15803D,stroke-width:1.5px,color:#0B4A23
```

> [!WARNING]
>
> **Toda cobrança via `POST /v1/charges` é simulada no Modo Teste, inclusive com cartão salvo (`cardTokenId`) e Apple Pay.** Duas operações, porém, não têm modo de teste:
>
> * **Cadastro de cartão (`POST /v1/cards`):** registra o cartão de verdade no cofre e na adquirente, mas não cobra nada.
> * **Assinaturas (`POST /v1/subscriptions`):** as cobranças da assinatura são feitas de verdade, inclusive a validação de R\$ 1,00 (com estorno em seguida) dos planos com trial grátis.
>
> O cofre de cartões é o mesmo para teste e produção. Um `cardTokenId` criado durante os testes também funciona com a chave de produção, e aí a mesma chamada cobra de verdade.

Para homologar assinaturas, use um cartão real com valor baixo e cancele a assinatura no mesmo dia. O cancelamento em até 7 dias da criação estorna automaticamente as cobranças pagas.

### Cartões de teste

No Modo Teste, o resultado da cobrança de cartão depende só do número. Envie o número só com dígitos, sem espaços (com espaços, a API responde `400`).

| Número | Resultado | `status` / `reason` |
| - | - | - |
| `4444333322221111` | Aprovado | `paid` / `success` |
| `4444333322221112` | Recusado | `refused` / `card_declined` |
| Qualquer número terminado em `2222` (ex.: `4444333322222222`) | Pendente | `pending` / `pending`. A cobrança fica pendente e não há confirmação posterior simulada |
| Qualquer outro número | Aprovado | `paid` / `success` |

Nome, CVV e validade não mudam o resultado. Use qualquer nome, CVV numérico de 3 dígitos e validade futura (mês com 2 dígitos, ex.: `05`, e ano com 4). O parcelamento de 1 a 12 vezes funciona igual, desde que a conta tenha taxa configurada para o número de parcelas.

> [!NOTE]
>
> Esses números só valem com a chave de teste. As regras de 3D Secure e de antifraude da conta continuam valendo no Modo Teste: se a conta exige 3DS ou tem antifraude ligado, a recusa pode vir dessas etapas, com `reason` começando em `3ds_` ou igual a `antifraud_denied`. Na cobrança com cartão salvo, a regra vale para o número guardado; como esse cartão costuma ser real, a cobrança de teste sai aprovada.

## Onde obter as chaves

As chaves ficam no [painel da Finvia](https://app.finvia.com.br), em **Configurações > Chave de API**. A página se chama **Chaves de API** e tem duas abas: **Produção** e **Teste**. Não existe rota de API para a conta ler as próprias chaves.

**Em validação (V-56):** os rótulos do painel citados nesta seção estão sendo conferidos na versão em produção. Se algum nome estiver diferente, procure a página de chaves em **Configurações**.

O desenho abaixo resume o caminho da conta aprovada até as chaves de teste e de produção.

```mermaid placement="top-right" className="finvia-diagrama" theme={null}
%%{init: {"theme": "base", "fontFamily": "Inter, sans-serif", "themeVariables": {"fontFamily": "Inter, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#EAF3FF", "primaryBorderColor": "#017AFF", "primaryTextColor": "#070D15", "secondaryColor": "#F3F5F8", "tertiaryColor": "#FFFFFF", "lineColor": "#5B6B82", "textColor": "#070D15", "edgeLabelBackground": "#FFFFFF", "clusterBkg": "#F7F9FC", "clusterBorder": "#D5DCE6", "actorBkg": "#FFFFFF", "actorBorder": "#98A2B3", "actorTextColor": "#070D15", "actorLineColor": "#B8C2D1", "signalTextColor": "#070D15", "labelBoxBkgColor": "#EAF3FF", "labelBoxBorderColor": "#017AFF", "labelTextColor": "#003A7A", "loopTextColor": "#070D15", "noteBkgColor": "#FFF6E5", "noteBorderColor": "#F0B44C", "noteTextColor": "#5C3D00", "activationBkgColor": "#EAF3FF", "activationBorderColor": "#017AFF", "sequenceNumberColor": "#FFFFFF", "signalColor": "#5B6B82"}, "flowchart": {"curve": "basis", "nodeSpacing": 45, "rankSpacing": 55, "padding": 18}, "sequence": {"mirrorActors": false, "showSequenceNumbers": true, "actorMargin": 60, "messageMargin": 38, "boxMargin": 10, "noteMargin": 12, "wrap": true}}}%%
flowchart TB
    A(["Conta cadastrada<br/>e aprovada"]):::neutro
    AUTO["Par sk_ / pk_ de produção<br/>criado automaticamente<br/>pertence ao proprietário"]:::finvia
    P["Painel: Configurações ><br/>Chave de API (V-56)"]:::lojista
    Q{"Qual aba?"}:::decisao
    GT["Gerar chave de teste<br/>e confirmar em Criar chave"]:::lojista
    TPAIR["Par sk_test_ / pk_test_"]:::alerta
    GP["Se ainda não existir:<br/>Gerar chave de produção"]:::lojista
    REV["Revelar chave<br/>código no e-mail, vale 5 min"]:::lojista
    SK["Chave secreta<br/>só no servidor"]:::ok
    PK["Chave pública<br/>no front-end"]:::ok
    A --> AUTO
    A -->|"usuário Owner ou Manager"| P
    P --> Q
    Q -->|"Teste"| GT
    GT --> TPAIR
    Q -->|"Produção"| GP
    AUTO -.-> GP
    TPAIR --> REV
    GP --> REV
    REV --> SK
    REV --> PK
    classDef alerta fill:#FFF6E5,stroke:#B45309,stroke-width:1.5px,color:#5C3D00
    classDef decisao fill:#FFFFFF,stroke:#017AFF,stroke-width:2px,color:#070D15
    classDef finvia fill:#017AFF,stroke:#0060CC,stroke-width:1.5px,color:#FFFFFF,font-weight:600
    classDef lojista fill:#F3F5F8,stroke:#475467,stroke-width:1.5px,color:#101828
    classDef neutro fill:#FFFFFF,stroke:#B8C2D1,stroke-width:1.5px,color:#344054
    classDef ok fill:#E8F7EE,stroke:#15803D,stroke-width:1.5px,color:#0B4A23
```

Os nomes do painel usados no desenho seguem a mesma ressalva de validação (V-56) do quadro acima.

> [tab] Chave de produção
>
> **1. Abra a aba Produção**
>
> Em **Configurações > Chave de API**, abra a aba **Produção**. O par `sk_`/`pk_` de produção é criado automaticamente no cadastro ou na aprovação da conta e pertence ao proprietário dela. Se ele ainda não existir, a aba mostra o botão **Gerar chave de produção**.
>
> **2. Revele a chave**
>
> Clique em **Revelar chave**. Um código de verificação é enviado ao seu e-mail e vale 5 minutos.
>
> **3. Copie o par**
>
> Depois de informar o código, o painel mostra juntas a **Chave secreta** (`sk_`) e a **Chave pública** (`pk_`). Guarde a secreta em um cofre de segredos ou na variável de ambiente do servidor.

> [tab] Chave de teste
>
> **1. Abra a aba Teste**
>
> Em **Configurações > Chave de API**, abra a aba **Teste**.
>
> **2. Gere o par de teste**
>
> Clique em **Gerar chave de teste** e confirme em **Criar nova chave de API?** > **Criar chave**. O sistema gera o par `sk_test_`/`pk_test_`.
>
> **3. Revele a chave**
>
> Clique em **Revelar chave**, informe o código enviado ao seu e-mail (válido por 5 minutos) e copie a **Chave secreta** (`sk_test_`) e a **Chave pública** (`pk_test_`).

No painel, os perfis Owner, Manager e Desenvolvedor podem gerar e revelar chaves. O perfil Visualizador só vê a página. Para a integração, gere as chaves, inclusive a de teste, com um usuário **Owner** ou **Manager**: uma chave gerada por Desenvolvedor fica com as restrições desse perfil (veja [Permissões da chave](#permissões-da-chave)).

A `sk_` e a `pk_` formam um par. Se a chave secreta for trocada (a troca é feita pelo suporte), a chave pública também muda e precisa ser atualizada no front-end. Cada par pertence a uma única conta.

Formato de uma chave:

```text theme={null}
sk_9a8s7d6f5g4h3j2k1l0z9x8c7v6b5n4m3
```

### Permissões da chave

A chave **age com as permissões do usuário que a gerou**. Quem apenas revela a chave no painel não muda essas permissões. A chave de produção criada automaticamente pertence ao proprietário da conta e funciona em todas as rotas. Uma chave gerada por outro usuário fica limitada ao perfil dele, e isso vale também para a chave de teste.

| Perfil do usuário que gerou a chave | O que a chave consegue fazer |
| - | - |
| Owner, Manager e Operador | Cobranças, planos e assinaturas |
| Visualizador | Só as consultas (`GET`) de planos e assinaturas. As demais rotas de planos e assinaturas respondem `403` |
| Desenvolvedor | Não cria cobranças nem acessa planos e assinaturas. Também recebe `403` em saldo (`GET /v1/wallets`) e em saques (`/v1/payout-requests`) |
| Financeiro | Recebe `403` em todas as rotas de planos e assinaturas |
| Perfil personalizado | Depende das permissões marcadas no perfil |

Quando falta permissão, a resposta é:

```json theme={null}
{ "message": "Acesso negado", "error": "Forbidden", "statusCode": 403 }
```

> [!TIP]
>
> **Para o desenvolvedor:** gere a chave de teste com um usuário Owner ou Manager. Se ela for gerada por um usuário Desenvolvedor, os testes de cobrança falham com `403`. Quando a integração consulta dados mas recebe `403` ao criar cobranças, confira primeiro o perfil de quem gerou a chave.

## Como se autenticar

A API usa **HTTP Basic Auth**. A chave secreta vai no lugar do usuário e a senha fica vazia. Passo a passo:

**1. Pegue a chave**

`sk_abc123`

**2. Acrescente dois pontos no final**

`sk_abc123:` (os dois pontos separam usuário e senha; como a senha é vazia, não há nada depois deles)

**3. Converta para Base64**

`c2tfYWJjMTIzOg==`

**4. Envie no cabeçalho de toda requisição**

`Authorization: Basic c2tfYWJjMTIzOg==`

> [!TIP]
>
> **Para o desenvolvedor:** para conferir se o Base64 foi montado certo, decodifique o valor e veja se ele termina com `:`. Se os dois pontos estiverem faltando, a API responde `401`.

### Teste a conexão

A forma mais simples de validar a chave é listar os meios de pagamento disponíveis para a sua conta. Resposta `200` significa que a autenticação está correta.

```http REST (JSON) theme={null}
GET /v1/payment-methods HTTP/1.1
Host: api-global.fastpaybrasil.com
Authorization: Basic <base64 de "SUA_CHAVE_SECRETA:">
```

```bash cURL theme={null}
curl -X GET "https://api-global.fastpaybrasil.com/v1/payment-methods" \
  -u "$FINVIA_API_KEY:"
```

```javascript Node.js theme={null}
// conexao.mjs (Node.js 18+, ESM, await no topo)
const API_URL = 'https://api-global.fastpaybrasil.com';
const apiKey = process.env.FINVIA_API_KEY;
const credentials = Buffer.from(`${apiKey}:`).toString('base64');

const response = await fetch(`${API_URL}/v1/payment-methods`, {
  headers: { Authorization: `Basic ${credentials}` },
});

console.log(response.status, await response.json());
```

```php PHP theme={null}
<?php
$apiKey = getenv('FINVIA_API_KEY');
$credentials = base64_encode("$apiKey:");

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => 'https://api-global.fastpaybrasil.com/v1/payment-methods',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Basic ' . $credentials,
        'Content-Type: application/json'
    ]
]);

$response = curl_exec($curl);
curl_close($curl);
```

```python Python theme={null}
import os
import base64
import requests

api_key = os.environ['FINVIA_API_KEY']
credentials = base64.b64encode(f'{api_key}:'.encode()).decode()

response = requests.get(
    'https://api-global.fastpaybrasil.com/v1/payment-methods',
    headers={
        'Authorization': f'Basic {credentials}',
        'Content-Type': 'application/json',
    },
)
```

```java Java theme={null}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Base64;

public class Exemplo {
    public static void main(String[] args) throws Exception {
        String credentials = Base64.getEncoder()
            .encodeToString((System.getenv("FINVIA_API_KEY") + ":").getBytes());

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api-global.fastpaybrasil.com/v1/payment-methods"))
            .header("Authorization", "Basic " + credentials)
            .method("GET", HttpRequest.BodyPublishers.noBody())
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}
```

```csharp C# theme={null}
using System.Net.Http.Headers;
using System.Text;

var apiKey = Environment.GetEnvironmentVariable("FINVIA_API_KEY");
var credentials = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{apiKey}:"));

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", credentials);

var request = new HttpRequestMessage(HttpMethod.Get, "https://api-global.fastpaybrasil.com/v1/payment-methods");

var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode);
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

```go Go theme={null}
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest("GET", "https://api-global.fastpaybrasil.com/v1/payment-methods", nil)
	if err != nil {
		panic(err)
	}
	req.SetBasicAuth(os.Getenv("FINVIA_API_KEY"), "")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	body, _ := io.ReadAll(res.Body)
	fmt.Println(res.StatusCode)
	fmt.Println(string(body))
}
```

```ruby Ruby theme={null}
require "net/http"
require "uri"

uri = URI("https://api-global.fastpaybrasil.com/v1/payment-methods")
request = Net::HTTP::Get.new(uri)
request.basic_auth(ENV.fetch("FINVIA_API_KEY"), "")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.code
puts response.body
```

## Boas práticas de segurança

* Guarde a chave em variável de ambiente ou cofre de segredos, nunca no código-fonte.
* Use chaves diferentes para cada ambiente e nunca reaproveite a chave de produção em testes.
* Use sempre HTTPS.
* Se houver suspeita de vazamento da chave secreta, peça a troca ao suporte imediatamente. Depois da troca, atualize a `sk_` no servidor e a `pk_` no front-end, porque as duas mudam juntas.
* Acompanhe os logs de acesso da sua aplicação para identificar uso fora do padrão.

```javascript theme={null}
// Evite: chave no código
// const apiKey = 'sk_9a8s7d6f5g4h3j2k1l0z9x8c7v6b5n4m3';

// Faça: chave em variável de ambiente
const apiKey = process.env.FINVIA_API_KEY;
console.log(apiKey ? 'Chave carregada do ambiente' : 'Defina FINVIA_API_KEY');
```

## Erros comuns

| Código | Resposta | Causa | Como resolver |
| - | - | - | - |
| `401` | `{"statusCode": 401, "message": "Unauthorized"}` | Chave inválida, cabeçalho ausente ou formato incorreto | Confira os dois pontos antes do Base64, o prefixo `Basic ` e se a chave é do ambiente certo |
| `403` | `{"message": "Acesso negado", "error": "Forbidden", "statusCode": 403}` | O perfil do usuário que gerou a chave não tem permissão para a rota | Gere a chave com um usuário Owner ou Manager |
| `403` | `WITHDRAWAL_NOT_ALLOWED_IN_TEST_MODE` | Pedido de saque com a chave de teste. Não existe saque no Modo Teste | Teste saques só em produção, com valor baixo |

## Perguntas frequentes

> [accordion] Preciso mudar a URL para sair do sandbox?
>
> Não. A URL é a mesma. Para ir para produção, troque a chave de teste (`sk_test_`) pela chave de produção (`sk_`).

> [accordion] Perdi a chave. Consigo ver de novo?
>
> Sim. Em **Configurações > Chave de API**, clique em **Revelar chave** e informe o código enviado ao seu e-mail.

> [accordion] Posso testar assinaturas com a chave de teste?
>
> As assinaturas cobram de verdade mesmo com a chave de teste, e o cadastro de cartão registra o cartão de verdade (sem cobrar). Use um cartão real com valor baixo e cancele a assinatura no mesmo dia: o cancelamento em até 7 dias da criação estorna automaticamente as cobranças pagas.

> [accordion] Uma cobrança com cartão salvo cobra de verdade no Modo Teste?
>
> Não. Com a chave de teste, toda cobrança em `POST /v1/charges` é simulada, inclusive com `cardTokenId`. O `cvv` continua obrigatório. Lembre que o mesmo `cardTokenId` cobra de verdade se for usado com a chave de produção.

> [accordion] Quem da minha empresa deve gerar a chave?
>
> Um usuário com perfil Owner ou Manager. Uma chave gerada por Desenvolvedor não cria cobranças nem assinaturas e não acessa saldo nem saques.

> [accordion] Os webhooks de teste vão para endpoints separados?
>
> Não. A lista de endpoints de webhook é uma só e recebe eventos de teste e de produção. Nos eventos de cobrança de teste, `livemode` vem `false` e `data.is_test` vem `true`. Veja [Sua primeira cobrança](https://docs.fastpaybrasil.com/primeiros-passos/primeira-cobranca.md).

## Veja também

> [card] [Sua primeira cobrança](https://docs.fastpaybrasil.com/primeiros-passos/primeira-cobranca.md)
>
> Crie e acompanhe uma cobrança Pix no sandbox.

> [card] [Paginação, ordenação e idempotência](https://docs.fastpaybrasil.com/primeiros-passos/paginacao-ordenacao-idempotencia.md)
>
> Como listar dados e evitar cobranças duplicadas.

> [card] [Erros e como tratar](https://docs.fastpaybrasil.com/primeiros-passos/erros.md)
>
> Códigos HTTP e respostas de erro da API.

> [card] [Roteiro de homologação](https://docs.fastpaybrasil.com/homologacao/roteiro.md)
>
> O que testar antes de ir para produção.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.