Este artigo é dirigido a desenvolvedores e equipes técnicas que chamam a API Axeptio diretamente — a partir de código, script, integração personalizada ou cliente HTTP como Postman.

Axeptio autentica suas requisições por meio de um token Bearer de curta duração. Primeiro você gera um token pessoal na administração Axeptio, que fornece um identificador de cliente e uma chave secreta. Em seguida, você troca essas credenciais por um access_token válido por 1 hora, que você transmite em cada uma de suas requisições.

Como funciona a autenticação

Gerar um token pessoal na administração Axeptio. Você recebe um identificador de cliente e uma chave secreta que identificam sua integração.
Obter um access token apresentando este identificador de cliente e essa chave secreta. Você recebe um access_token válido por 1 hora e um refresh_token.
Enviar suas requisições para a API Axeptio incluindo o access_token no header Authorization: Bearer de cada uma delas.
Atualizar o access token antes de sua expiração, sem precisar inserir novamente o identificador de cliente e a chave secreta.

Duas durações de vida distintas entram em jogo. O token pessoal — o identificador de cliente e a chave secreta — tem a duração de expiração que você escolhe na sua criação: é sua credencial de longa duração. O access_token obtido a partir deste token expira após uma hora: é ele que seu código deve atualizar automaticamente.

1. Gerar um token pessoal na administração Axeptio

Conecte-se à administração Axeptio.
Na barra de navegação, clique em Conta.
Clique em Preferências de segurança — uma janela se abrirá.
No menu, selecione Tokens pessoais.
Clique em Gerar token, dê um nome ao seu token e escolha uma duração de expiração. Recomendamos evitar a opção Nunca: um token que não expira continua válido indefinidamente em caso de vazamento. Se você não sabe o que escolher, opte por 90 dias para uma integração em produção ou 7 dias para uso pontual ou teste.
Copie o Identificador do cliente e a Chave secreta que aparecem — eles não serão mais visíveis após esta etapa.

Guarde o identificador do cliente e a chave secreta em local seguro — eles não podem ser recuperados após a geração. Nunca os coloque em seu código: armazene-os em variáveis de ambiente.

Você pode gerar quantos tokens forem necessários — o nome permite identificá-los. Isso é útil se você tiver vários ambientes (desenvolvimento, produção) ou várias integrações: cada token é independente, o que permite revogar o acesso de uma integração específica sem afetar as outras.

2. Obter um access token

Chame o endpoint de autenticação com seu identificador de cliente e sua chave secreta. Você recebe em retorno um access_token, válido por 1 hora, e um refresh_token para renová-lo.

curl -X POST https://login.axept.io/identity/resources/auth/v2/api-token \
  -H "Content-Type: application/json" \
  -d '{ "clientId": "<CLIENT_ID>", "secret": "<SECRET>" }'

Resposta:

{
  "access_token": "eyJ...",
  "refresh_token": "dGhp...",
  "expires_in": 3600
}

3. Enviar suas requisições para a API Axeptio

Inclua o access_token no header Authorization de cada requisição.

curl https://api.axept.io/v1/<ENDPOINT> \
  -H "Authorization: Bearer <ACCESS_TOKEN>"

4. Atualizar o access token antes de sua expiração

O access_token expira após 1 hora. Antes de cada requisição, verifique se ainda é válido e atualize-o se necessário — sem precisar inserir novamente o identificador de cliente e a chave secreta.

curl -X POST https://login.axept.io/identity/resources/auth/v2/api-token/token/refresh \
  -H "Content-Type: application/json" \
  -d '{ "refreshToken": "<REFRESH_TOKEN>" }'

Exemplos de código completos

TypeScript / Node.js

const AUTH_URL = "https://login.axept.io";
const AXEPTIO_API = "https://api.axept.io/v1";

interface TokenResponse {
  access_token: string;
  refresh_token: string;
  expires_in: number;
}

async function getAccessToken(clientId: string, secret: string): Promise<TokenResponse> {
  const res = await fetch(`${AUTH_URL}/identity/resources/auth/v2/api-token`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ clientId, secret }),
  });
  if (!res.ok) throw new Error(`Token fetch failed: ${res.status}`);
  return res.json();
}

async function refreshAccessToken(refreshToken: string): Promise<TokenResponse> {
  const res = await fetch(`${AUTH_URL}/identity/resources/auth/v2/api-token/token/refresh`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ refreshToken }),
  });
  if (!res.ok) throw new Error(`Token refresh failed: ${res.status}`);
  return res.json();
}

async function callAxeptioApi(accessToken: string, path: string) {
  const res = await fetch(`${AXEPTIO_API}${path}`, {
    headers: { Authorization: `Bearer ${accessToken}` },
  });
  if (!res.ok) throw new Error(`API call failed: ${res.status}`);
  return res.json();
}

// Utilização com atualização automática
let token = await getAccessToken(CLIENT_ID, SECRET);

let expiresAt = Date.now() + token.expires_in * 1000;

async function apiCall(path: string) {
  // Atualiza 60 s antes da expiração para evitar rejeições em caso de latência de rede
  if (Date.now() > expiresAt - 60_000) {
    token = await refreshAccessToken(token.refresh_token);
    expiresAt = Date.now() + token.expires_in * 1000;
  }
  return callAxeptioApi(token.access_token, path);
}

Python

import time
import requests

AUTH_URL = "https://login.axept.io"
AXEPTIO_API = "https://api.axept.io/v1"

def get_access_token(client_id: str, secret: str) -> dict:
    res = requests.post(
        f"{AUTH_URL}/identity/resources/auth/v2/api-token",
        json={"clientId": client_id, "secret": secret},
    )
    res.raise_for_status()
    return res.json()

def refresh_access_token(refresh_token: str) -> dict:
    res = requests.post(
        f"{AUTH_URL}/identity/resources/auth/v2/api-token/token/refresh",
        json={"refreshToken": refresh_token},
    )
    res.raise_for_status()
    return res.json()

def call_axeptio_api(access_token: str, path: str) -> dict:
    res = requests.get(
        f"{AXEPTIO_API}{path}",
        headers={"Authorization": f"Bearer {access_token}"},
    )
    res.raise_for_status()
    return res.json()

# Utilização com atualização automática
token = get_access_token(CLIENT_ID, SECRET)

expires_at = time.time() + token["expires_in"]

def api_call(path: str) -> dict:
    global token, expires_at
    if time.time() > expires_at - 60:  # 60 s de margem para evitar rejeições em caso de latência de rede
        token = refresh_access_token(token["refresh_token"])
        expires_at = time.time() + token["expires_in"]
    return call_axeptio_api(token["access_token"], path)

Referência

A lista completa dos endpoints disponíveis está documentada no Swagger Axeptio (em atualização). Para uma visão geral do que a API permite fazer, consulte Usar a API Axeptio.

Se suas requisições para a API retornam um erro de autenticação

Verifique como seu código obtém seu token. Se ele enviar um username e password, essa é a causa: esse método não existe mais desde 10 de julho de 2026 e os tokens que ele produzia foram invalidados.

Gere um token pessoal seguindo a etapa 1, então substitua a requisição que transmite seu username e password pela da etapa 2. O resto de sua integração permanece inalterado: o header Authorization: Bearer é idêntico.

Precisa de ajuda?

Se suas requisições falharem, se suas credenciais não estiverem visíveis na administração Axeptio ou para qualquer outra pergunta, não hesite em contatar nossa equipe de suporte.

Autenticar suas solicitações na API Axeptio