Baixe a coleção do Postman com todos os endpoints da API Atys, organizados por módulo — é só preencher a sua chave de API.
Baixar coleção PostmanAuthorization: Bearer …. Você escolhe o que vai nele: uma chave de API
ou um access_token obtido com login.
Como funciona
Toda integração usa um usuário API, criado em Configurações → Usuários API. A partir dele há duas formas de autenticar — as duas continuam válidas e podem ser usadas ao mesmo tempo:
- O administrador gera a chave na plataforma e marca o que ela pode fazer.
- Seu sistema envia a chave no header
Authorization. Não há login.
- Não expira (a menos que você defina uma data)
- Só acessa o que foi marcado
- Revogável sem afetar outras integrações
- Seu sistema faz login com o e-mail e a senha do usuário API e recebe um
access_token. - Envia o token no header
Authorizatione repete o login quando ele expira.
- Expira em 45 dias (16 horas sem "lembrar")
- Um novo login derruba o token anterior
- Acessa tudo o que o usuário API pode
| Chave de API | Login com usuário API | |
|---|---|---|
| Como obter | Gerada uma vez na plataforma | POST /api/oauth/token com e-mail e senha |
| Validade | Não expira, salvo data definida | 45 dias (16 horas sem "lembrar") |
| Novo login | Não afeta a chave | Derruba o token anterior do mesmo dispositivo |
| Permissões | Só as marcadas na chave | Tudo o que o usuário API pode |
| Revogar | Botão Revogar, só aquela chave | Trocando a senha do usuário API |
| Endpoints | Os da API v1 e os já documentados | Todos |
Já integra com login? Nada muda: o POST /api/oauth/token continua funcionando.
Para integrações novas, prefira a chave.
Chave de API (recomendado)
A chave de API é a forma recomendada de autenticar integrações. Ela é gerada pelo administrador da empresa e não depende de e-mail e senha: não expira (a menos que você defina uma data), não é derrubada por um novo login e pode ser revogada a qualquer momento sem afetar outras integrações.
Como gerar
- Na plataforma Atys, acesse Configurações → Usuários de API e crie um usuário API, se ainda não tiver.
- Na linha do usuário, clique no ícone de chave e em Gerar chave.
- Dê um nome (ex.: ERP), marque as permissões e, se quiser, uma data de expiração.
- Copie a chave exibida. Ela aparece uma única vez; se perder, revogue e gere outra.
Como usar
Envie a chave no header Authorization, exatamente como um access_token.
Não há passo de login.
Exemplo de requisição com chave de API
curl https://api.atys.pro/api/v1/crm/pipelines \
-H "Authorization: Bearer atys_live_SUA_CHAVE" \
-H "Accept: application/json"
const response = await fetch('https://api.atys.pro/api/v1/crm/pipelines', {
headers: {
'Authorization': `Bearer ${process.env.ATYS_API_KEY}`,
'Accept': 'application/json'
}
});
const data = await response.json();
import os
import requests
response = requests.get(
'https://api.atys.pro/api/v1/crm/pipelines',
headers={
'Authorization': f"Bearer {os.environ['ATYS_API_KEY']}",
'Accept': 'application/json'
}
)
data = response.json()
<?php
$ch = curl_init('https://api.atys.pro/api/v1/crm/pipelines');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer '.getenv('ATYS_API_KEY'),
'Accept: application/json'
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
<?php
$client = new GuzzleHttp\Client();
$response = $client->get('https://api.atys.pro/api/v1/crm/pipelines', [
'headers' => [
'Authorization' => 'Bearer '.getenv('ATYS_API_KEY'),
'Accept' => 'application/json'
]
]);
package main
import (
"fmt"
"io"
"net/http"
"os"
)
func main() {
req, _ := http.NewRequest("GET", "https://api.atys.pro/api/v1/crm/pipelines", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("ATYS_API_KEY"))
req.Header.Set("Accept", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
Permissões
A chave só acessa os endpoints das permissões marcadas na criação:
| Permissão | Endpoints |
|---|---|
| Enviar mensagens e consultar conversas | Envio pelo WhatsApp Oficial (api-send-message com ofc_whatsapp), edição e revogação de mensagens, conversas (contact-channels), canais (company-channels) e templates |
| Consultar CRM | CRM (API v1): todas as consultas — funil, catálogos, negócios, notas, tarefas, histórico, agendamentos, documentos e relatórios |
| Criar, editar e mover negócios do CRM | CRM (API v1): criar, editar, mover, ganhar/perder, arquivar, transferir, clonar e importar negócios; notas, tarefas, agendamentos, documentos e anexos |
| Consultar WhatsApp Oficial | WhatsApp Oficial (API v1): WABAs, números, qualidade, modo de operação, consumo, templates, grupos e ligações |
| Gerenciar WhatsApp Oficial | WhatsApp Oficial (API v1): cadastrar números, teto de gastos, criar e editar templates, grupos, participantes e ligações |
| Excluir no WhatsApp Oficial | WhatsApp Oficial (API v1): excluir templates, grupos, números e WABAs |
| Consultar tickets | Tickets (API v1): tickets, catálogos, atendentes, contatos, etiquetas, interações e anexos |
| Criar, editar e responder tickets | Tickets (API v1): abrir e editar tickets, status, prioridade, responsável, vínculos, fixar; responder, notas internas, anexos e acesso do contato |
| Consultar conversas e mensagens | Omnichat (API v1): conversas, contador de não lidas, histórico, templates e respostas rápidas |
| Atender conversas e enviar mensagens | Omnichat (API v1): atribuir, transferir, fixar, arquivar, encerrar e reabrir; enviar, editar, apagar, reagir e encaminhar mensagens |
| Consultar contatos | Contatos (API v1): contatos, canais, campos, etiquetas, catálogos e status de importação e exportação |
| Gerenciar contatos | Contatos (API v1): cadastrar e editar contatos e canais, campos, etiquetas, ações em lote, importação e exportação |
| Excluir contatos | Contatos (API v1): excluir contatos e canais, inclusive em lote |
| Consultar agenda | Agenda (API v1): eventos, participantes, lembretes, anexos, horários, disponibilidade e conflitos |
| Gerenciar agenda | Agenda (API v1): criar, editar e excluir eventos; participantes, lembretes, anexos, horário de atendimento, reservas e links de agendamento |
| Configurar o CRM | CRM (API v1): pipelines, etapas, tarefas padrão, campos, etiquetas, motivos de perda e gatilhos |
| Excluir negócios do CRM | CRM (API v1): excluir negócios |
| Gerenciar webhooks | Webhooks: assinaturas, eventos disponíveis, teste, entregas e rotação de segredo |
Qualquer outro endpoint responde 403 para a chave, mesmo que o usuário API tenha
acesso a ele pela plataforma.
Login: obter o access_token
Método anterior, que continua funcionando: login com o e-mail e a senha do usuário API. Para integrações novas, prefira a chave de API.
Para obter o token de autenticação, faça uma requisição POST para
https://api.atys.pro/api/oauth/token com suas credenciais.
Parâmetros do body (JSON)
| Parâmetro | Tipo | Obrigatório | Descrição | Valor |
|---|---|---|---|---|
email | string | Sim | E-mail do usuário API | joao@exemplo.com |
password | string | Sim | Senha do usuário API | senha123 |
grant_type | string | Sim | Tipo de grant | password |
device_name | string | Não | web (padrão) ou mobile; outro valor responde 422. Um novo login derruba só o token anterior com o mesmo device_name. Ver renovação. | web |
remember | boolean | Não | Validade do token: true (default) = 45 dias; false = 16 horas. | true |
Exemplos de código
const response = await fetch('https://api.atys.pro/api/oauth/token', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Accept': 'application/json'
},
body: JSON.stringify({
email: 'seu-email@exemplo.com',
password: 'sua-senha-segura',
grant_type: 'password'
})
});
const data = await response.json();
console.log(data.access_token);
import requests
response = requests.post(
'https://api.atys.pro/api/oauth/token',
headers={
'Content-Type': 'application/json',
'Accept': 'application/json'
},
json={
'email': 'seu-email@exemplo.com',
'password': 'sua-senha-segura',
'grant_type': 'password'
}
)
data = response.json()
print(data['access_token'])
<?php
$ch = curl_init('https://api.atys.pro/api/oauth/token');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Accept: application/json'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
'email' => 'seu-email@exemplo.com',
'password' => 'sua-senha-segura',
'grant_type' => 'password'
]));
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
echo $data['access_token'];
<?php
// composer require guzzlehttp/guzzle
use GuzzleHttp\Client;
$client = new Client();
$response = $client->post('https://api.atys.pro/api/oauth/token', [
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json'
],
'json' => [
'email' => 'seu-email@exemplo.com',
'password' => 'sua-senha-segura',
'grant_type' => 'password'
]
]);
$data = json_decode($response->getBody(), true);
echo $data['access_token'];
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)
func main() {
payload := map[string]string{
"email": "seu-email@exemplo.com",
"password": "sua-senha-segura",
"grant_type": "password",
}
jsonData, _ := json.Marshal(payload)
resp, err := http.Post(
"https://api.atys.pro/api/oauth/token",
"application/json",
bytes.NewBuffer(jsonData),
)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
var result map[string]interface{}
json.Unmarshal(body, &result)
fmt.Println(result["access_token"])
}
curl -X POST https://api.atys.pro/api/oauth/token \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-d '{
"email": "seu-email@exemplo.com",
"password": "sua-senha-segura",
"grant_type": "password"
}'
Resposta de sucesso (200 OK)
{
"access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
"token_type": "Bearer",
"user_data": {
"id": 123,
"name": "João Silva",
"email": "joao@exemplo.com",
"company_id": 45,
// ... demais campos do usuário
}
}
Usando o access_token
Após obter o token, inclua-o no header Authorization de todas as requisições
subsequentes:
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...
Exemplo de requisição autenticada
const response = await fetch('https://api.atys.pro/api/contacts', {
method: 'GET',
headers: {
'Authorization': 'Bearer SEU_ACCESS_TOKEN',
'Accept': 'application/json'
}
});
const data = await response.json();
import requests
response = requests.get(
'https://api.atys.pro/api/contacts',
headers={
'Authorization': 'Bearer SEU_ACCESS_TOKEN',
'Accept': 'application/json'
}
)
data = response.json()
<?php
$ch = curl_init('https://api.atys.pro/api/contacts');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer SEU_ACCESS_TOKEN',
'Accept: application/json'
]);
$response = curl_exec($ch);
$data = json_decode($response, true);
curl_close($ch);
<?php
use GuzzleHttp\Client;
$client = new Client();
$response = $client->get('https://api.atys.pro/api/contacts', [
'headers' => [
'Authorization' => 'Bearer SEU_ACCESS_TOKEN',
'Accept' => 'application/json'
]
]);
$data = json_decode($response->getBody(), true);
package main
import (
"encoding/json"
"io"
"net/http"
)
func main() {
req, _ := http.NewRequest(
"GET",
"https://api.atys.pro/api/contacts",
nil,
)
req.Header.Set("Authorization", "Bearer SEU_ACCESS_TOKEN")
req.Header.Set("Accept", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
var result map[string]interface{}
json.Unmarshal(body, &result)
}
curl -X GET https://api.atys.pro/api/contacts \
-H "Authorization: Bearer SEU_ACCESS_TOKEN" \
-H "Accept: application/json"
Renovação do token
O access_token obtido com e-mail e senha vale por 45 dias (16 horas se o
login for feito com "remember": false). Não existe um endpoint separado de renovação:
renovar é fazer login de novo com POST /api/oauth/token. A plataforma
invalida o token antes do prazo — e a próxima chamada recebe 401 — quando:
- outro login é feito com o mesmo usuário e o mesmo
device_name(o padrão éweb); - as permissões ou o cargo do usuário API são alterados, ou o acesso dele a canais muda;
- o usuário é bloqueado ou excluído;
- a senha é redefinida pelo fluxo de recuperação ("esqueci minha senha");
- o usuário tem horário de acesso configurado e a chamada acontece fora dele;
- a empresa é bloqueada ou suspensa (com restrição de cobrança a resposta é
402, sem invalidar o token).
Como renovar automaticamente
- Guarde o token (cache, banco ou arquivo) e reaproveite-o em todas as chamadas — não faça login a cada requisição.
- Ao receber
401, faça login de novo, guarde o token novo e repita a chamada uma única vez. Se o segundo401vier, pare e avise: as credenciais estão erradas ou o usuário foi bloqueado. - Uma integração por usuário API. Cada usuário tem no máximo um token por
device_name(weboumobile), então duas integrações que fazem login com o mesmo usuário se derrubam. Crie um usuário API para cada uma — ou, melhor, use uma chave de API por integração, que não depende de login. - Opcional: renove antes de vencer — por exemplo, refaça o login a cada 40 dias. A resposta do login não informa a data de expiração; conte a partir do momento do login.
Exemplo: renovar o token ao receber 401
#!/usr/bin/env bash
# Guarda o token num arquivo; se a chamada voltar 401, faz login de novo e repete UMA vez.
TOKEN_FILE=/tmp/atys_token
login() {
curl -s -X POST https://api.atys.pro/api/oauth/token \
-H "Content-Type: application/json" -H "Accept: application/json" \
-d "{\"email\":\"$ATYS_EMAIL\",\"password\":\"$ATYS_PASSWORD\",\"grant_type\":\"password\",\"device_name\":\"web\"}" \
| sed -E 's/.*"access_token":"([^"]+)".*/\1/' > "$TOKEN_FILE"
}
atys() { # uso: atys GET /api/v1/crm/pipelines
[ -s "$TOKEN_FILE" ] || login
status=$(curl -s -o /tmp/atys_body -w "%{http_code}" -X "$1" "https://api.atys.pro$2" \
-H "Authorization: Bearer $(cat "$TOKEN_FILE")" -H "Accept: application/json")
if [ "$status" = "401" ]; then
login
curl -s -X "$1" "https://api.atys.pro$2" \
-H "Authorization: Bearer $(cat "$TOKEN_FILE")" -H "Accept: application/json"
else
cat /tmp/atys_body
fi
}
atys GET /api/v1/crm/pipelines
let token = null; // guarde em cache/banco para reaproveitar entre execuções
async function login() {
const res = await fetch('https://api.atys.pro/api/oauth/token', {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
body: JSON.stringify({
email: process.env.ATYS_EMAIL,
password: process.env.ATYS_PASSWORD,
grant_type: 'password',
device_name: 'web' // 'web' (padrão) ou 'mobile': um novo login derruba o token anterior do mesmo nome
})
});
if (!res.ok) throw new Error('Login na Atys falhou: ' + await res.text());
token = (await res.json()).access_token;
}
async function atys(path, options = {}, retried = false) {
if (!token) await login();
const res = await fetch('https://api.atys.pro' + path, {
...options,
headers: { ...options.headers, 'Authorization': `Bearer ${token}`, 'Accept': 'application/json' }
});
if (res.status === 401 && !retried) { // token expirado ou revogado
await login();
return atys(path, options, true); // repete UMA vez
}
return res;
}
const res = await atys('/api/v1/crm/pipelines');
import os
import requests
BASE = 'https://api.atys.pro'
_token = None # guarde em cache/banco para reaproveitar entre execuções
def login():
global _token
res = requests.post(f'{BASE}/api/oauth/token', json={
'email': os.environ['ATYS_EMAIL'],
'password': os.environ['ATYS_PASSWORD'],
'grant_type': 'password',
'device_name': 'web', # 'web' (padrão) ou 'mobile'
}, headers={'Accept': 'application/json'})
res.raise_for_status()
_token = res.json()['access_token']
def atys(method, path, **kwargs):
if _token is None:
login()
for attempt in range(2):
res = requests.request(method, BASE + path, headers={
'Authorization': f'Bearer {_token}',
'Accept': 'application/json',
}, **kwargs)
if res.status_code != 401 or attempt == 1:
return res
login() # expirado ou revogado: novo login e repete UMA vez
res = atys('GET', '/api/v1/crm/pipelines')
<?php
function atysLogin(): string
{
$ch = curl_init('https://api.atys.pro/api/oauth/token');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ['Content-Type: application/json', 'Accept: application/json'],
CURLOPT_POSTFIELDS => json_encode([
'email' => getenv('ATYS_EMAIL'),
'password' => getenv('ATYS_PASSWORD'),
'grant_type' => 'password',
'device_name' => 'web', // 'web' (padrão) ou 'mobile'
]),
]);
$token = json_decode(curl_exec($ch), true)['access_token'] ?? null;
curl_close($ch);
file_put_contents(sys_get_temp_dir().'/atys_token', (string) $token); // cache
return (string) $token;
}
function atys(string $method, string $path, bool $retried = false): array
{
$cache = sys_get_temp_dir().'/atys_token';
$token = is_file($cache) ? file_get_contents($cache) : atysLogin();
$ch = curl_init('https://api.atys.pro'.$path);
curl_setopt_array($ch, [
CURLOPT_CUSTOMREQUEST => $method,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ['Authorization: Bearer '.$token, 'Accept: application/json'],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($status === 401 && ! $retried) { // expirado ou revogado
atysLogin();
return atys($method, $path, true); // repete UMA vez
}
return json_decode($body, true) ?? [];
}
$pipelines = atys('GET', '/api/v1/crm/pipelines');
<?php
use GuzzleHttp\Client;
final class AtysClient
{
private Client $http;
private ?string $token = null; // guarde em cache para reaproveitar
public function __construct()
{
$this->http = new Client(['base_uri' => 'https://api.atys.pro/api/', 'http_errors' => false]);
}
public function request(string $method, string $uri, array $options = []): array
{
for ($attempt = 0; $attempt < 2; $attempt++) {
$this->token ??= $this->login();
$options['headers'] = ['Authorization' => 'Bearer '.$this->token, 'Accept' => 'application/json'];
$response = $this->http->request($method, $uri, $options);
if ($response->getStatusCode() !== 401) {
return json_decode($response->getBody(), true) ?? [];
}
$this->token = null; // expirado ou revogado: novo login e repete UMA vez
}
throw new RuntimeException('Credenciais da Atys recusadas.');
}
private function login(): string
{
$response = $this->http->post('oauth/token', [
'headers' => ['Accept' => 'application/json'],
'json' => [
'email' => getenv('ATYS_EMAIL'),
'password' => getenv('ATYS_PASSWORD'),
'grant_type' => 'password',
'device_name' => 'web', // 'web' (padrão) ou 'mobile'
],
]);
return json_decode($response->getBody(), true)['access_token'];
}
}
$pipelines = (new AtysClient)->request('GET', 'v1/crm/pipelines');
package atys
import (
"bytes"
"encoding/json"
"net/http"
"os"
"sync"
)
type Client struct {
mu sync.Mutex
token string // guarde em cache para reaproveitar
}
func (c *Client) login() error {
body, _ := json.Marshal(map[string]string{
"email": os.Getenv("ATYS_EMAIL"),
"password": os.Getenv("ATYS_PASSWORD"),
"grant_type": "password",
"device_name": "web", // "web" (padrão) ou "mobile"
})
resp, err := http.Post("https://api.atys.pro/api/oauth/token", "application/json", bytes.NewReader(body))
if err != nil {
return err
}
defer resp.Body.Close()
var out struct{ AccessToken string `json:"access_token"` }
if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
return err
}
c.mu.Lock()
c.token = out.AccessToken
c.mu.Unlock()
return nil
}
// Do executa a chamada; com 401 faz login de novo e repete UMA vez.
func (c *Client) Do(method, path string) (*http.Response, error) {
for attempt := 0; attempt < 2; attempt++ {
if c.token == "" {
if err := c.login(); err != nil {
return nil, err
}
}
req, _ := http.NewRequest(method, "https://api.atys.pro"+path, nil)
req.Header.Set("Authorization", "Bearer "+c.token)
req.Header.Set("Accept", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil || resp.StatusCode != http.StatusUnauthorized || attempt == 1 {
return resp, err
}
resp.Body.Close()
c.token = "" // expirado ou revogado
}
return nil, nil
}
Melhores práticas de segurança
- Use HTTPS em todas as requisições.
- Armazene tokens de forma segura (variáveis de ambiente).
- Nunca exponha tokens em URLs ou logs.
- Implemente rotação automática de tokens.
- Use senhas fortes para usuários API.
- Monitore uso anormal da API.
- Nunca commite tokens no Git.
- Não armazene tokens em cookies sem criptografia.
- Não compartilhe tokens entre diferentes ambientes.
- Evite hardcoding de credenciais.
- Não use tokens em requisições HTTP (sem S).
- Não ignore erros de autenticação.
Erros comuns de autenticação
401 Unauthorized — token inválido ou expirado
Causa: o token ou a chave de API está inválido, expirado, revogado ou não foi enviado.
Solução: com e-mail e senha, faça login novamente; com chave de API, gere uma nova chave.
{
"success": false,
"message": "Unauthenticated.",
"error_code": "TOKEN_EXPIRED"
}
403 Chave de API sem permissão para o endpoint
Causa: a chave é válida, mas o endpoint não pertence às permissões dela.
Solução: gere uma chave com a permissão necessária em Configurações → Usuários de API.
{
"message": "Esta chave de API não tem permissão para esta rota.",
"scopes": ["crm:read"]
}
422 Campos do login ausentes ou inválidos
Causa: falta email, password ou grant_type, ou um valor não é aceito (por exemplo device_name diferente de web e mobile). errors diz qual campo.
Solução: corrija o corpo da requisição conforme a tabela de parâmetros.
{
"message": "The password field is required.",
"errors": {
"password": ["The password field is required."]
}
}
509 Login recusado (texto simples, não JSON)
Causa: o login com e-mail e senha responde 509 com uma mensagem em texto simples quando:
- o e-mail ou a senha estão errados — E-mail ou senha inválidos. (a mesma mensagem para os dois casos);
- o usuário está fora do horário de acesso configurado para ele — Seu acesso ao sistema está restrito neste horário…;
- o usuário ou a empresa estão bloqueados, ou a empresa está suspensa por atraso de pagamento.
Solução: leia o corpo como texto, não como JSON. Confira as credenciais e, no caso do horário, libere o horário do usuário API em Configurações → Usuários API. Não repita o login em laço: as tentativas contam para o limite (429). A chave de API não depende do horário de acesso; usuário inativo ou empresa bloqueada, porém, também bloqueiam a chave.
HTTP/1.1 509
Content-Type: text/html; charset=utf-8
E-mail ou senha inválidos.
429 Too Many Requests
Causa: muitas tentativas de login em pouco tempo — até 10 por minuto por IP e 5 por minuto por e-mail.
Solução: espere os segundos do cabeçalho Retry-After antes de tentar de novo.
HTTP/1.1 429 Too Many Requests
Retry-After: 60
{
"message": "Too Many Attempts."
}