Pular para o conteúdo

Exemplos em cURL

Setup

Terminal window
export MYSE_API_BASE="https://api.mysebr.com.br/nfemyse-v3/rest"
export MYSE_API_TOKEN="seu_token_aqui"

Health check

Terminal window
curl -i "$MYSE_API_BASE/health"

Emitir NFCe e aguardar resultado (polling)

#!/bin/bash
set -euo pipefail
BASE="$MYSE_API_BASE"
TOKEN="$MYSE_API_TOKEN"
# 1. Emitir
RESP=$(curl -sS -X POST "$BASE/nfce/emissao" \
-H "Authorization: Token $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"serie": "65",
"cfop": "5102",
"numero-origem": "VENDA-'$(date +%s)'",
"tp_pagamento": "dinheiro",
"itens": [
{ "produto": "SKU-001", "quantidade": "1", "valor-unitario": "10.00" }
]
}')
echo "Resposta emissão: $RESP"
STATUS=$(echo "$RESP" | jq -r .status)
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
REQ_ID=$(echo "$RESP" | jq -r .meta.request_id)
if [ "$STATUS" != "001" ] && [ "$STATUS" != "050" ]; then
echo "Erro na emissão (request_id=$REQ_ID): $RESP" >&2
exit 1
fi
echo "Recibo: $RECIBO (request_id=$REQ_ID)"
# 2. Polling
WAIT=5
TERM_REGEX='^(004|010|900|999)$'
for i in $(seq 1 30); do
sleep $WAIT
RESP=$(curl -sS "$BASE/nfce/cupom/$RECIBO" \
-H "Authorization: Token $TOKEN")
STATUS=$(echo "$RESP" | jq -r .status)
echo "[$i] status=$STATUS"
if [[ $STATUS =~ $TERM_REGEX ]]; then
echo "Status terminal: $STATUS"
echo "$RESP" | jq .
exit 0
fi
# Backoff até 30s
WAIT=$(echo "$WAIT * 1.5" | bc | awk '{ printf "%d", $1 < 30 ? $1 : 30 }')
done
echo "Timeout aguardando recibo $RECIBO" >&2
exit 1

Listar NFes com paginação

Terminal window
PAGE=1
SIZE=20
while :; do
RESP=$(curl -sS "$MYSE_API_BASE/nfe?page=$PAGE&page_size=$SIZE" \
-H "Authorization: Token $MYSE_API_TOKEN")
STATUS=$(echo "$RESP" | jq -r .status)
[ "$STATUS" != "005" ] && { echo "Erro: $RESP"; break; }
COUNT=$(echo "$RESP" | jq '.data | length')
echo "Página $PAGE: $COUNT registros"
echo "$RESP" | jq -c '.data[]'
[ "$COUNT" -lt "$SIZE" ] && break
PAGE=$((PAGE + 1))
done

Helper de polling reutilizável

Terminal window
# Função genérica: aguarda recibo até status terminal.
# Uso: aguardar_recibo /nfe/nota $RECIBO
# Ao terminar, a última resposta fica na variável $RESP.
aguardar_recibo() {
local PATH_BASE="$1"
local RECIBO="$2"
local TERM_REGEX='^(004|010|900|999)$'
local WAIT=5
for i in $(seq 1 30); do
sleep $WAIT
RESP=$(curl -sS "$MYSE_API_BASE${PATH_BASE}/$RECIBO" \
-H "Authorization: Token $MYSE_API_TOKEN")
STATUS=$(echo "$RESP" | jq -r .status)
echo "[$i] status=$STATUS"
if [[ $STATUS =~ $TERM_REGEX ]]; then
echo "$RESP"
return 0
fi
WAIT=$(echo "$WAIT * 1.5" | bc | awk '{ printf "%d", $1 < 30 ? $1 : 30 }')
done
echo "Timeout aguardando recibo $RECIBO" >&2
return 1
}

Emitir NF-e (com transporte completo)

Terminal window
RESP=$(curl -sS -X POST "$MYSE_API_BASE/nfe/emissao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"serie": "1",
"cfop": "5102",
"numero-origem": "PED-'$(date +%s)'",
"tipo": "S",
"finalidade": "N",
"valor-despesas": "0.00",
"cliente": "12345678000199",
"transporte": {
"modalidade": "0",
"transportadora": "98765432000111",
"placa-veiculo": "ABC-1D23",
"valor-frete": "150.00",
"valor-seguro": "0.00",
"peso-bruto": "5.5",
"peso-liquido": "5.0",
"quantidade-volume": "1",
"especie-volume": "Caixa",
"marca-volume": "Embalagem padrao"
},
"itens": [
{ "produto": "SKU-001", "quantidade": "2", "valor-unitario": "89.90" }
],
"faturas": [
{ "valor": "179.80", "data": "2026-06-15" }
]
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
echo "Recibo NF-e: $RECIBO"
aguardar_recibo /nfe/nota "$RECIBO"

Cancelar NF-e

Terminal window
RESP=$(curl -sS -X POST "$MYSE_API_BASE/nfe/cancelamento" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chave": "35260512345678000199550010000000011000000010",
"motivo": "Cancelamento solicitado pelo cliente — pedido refeito."
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
aguardar_recibo /nfe/cancelamento "$RECIBO"

Lançar carta de correção (CC-e)

Terminal window
# "motivo" é o TEXTO da correção: 15 a 1000 caracteres (desde a 3.15.1).
# No cancelamento o motivo continua entre 15 e 255.
TEXTO="Correcao da descricao do item 3 — modelo correto: XYZ-2."
LEN=$(printf '%s' "$TEXTO" | wc -m | tr -d ' ')
if [ "$LEN" -lt 15 ] || [ "$LEN" -gt 1000 ]; then
echo "texto da correção deve ter entre 15 e 1000 caracteres (tem $LEN)" >&2
exit 1
fi
RESP=$(jq -n --arg chave "35260512345678000199550010000000011000000010" --arg motivo "$TEXTO" \
'{chave: $chave, motivo: $motivo}' \
| curl -sS -X POST "$MYSE_API_BASE/nfe/correcao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d @-)
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
aguardar_recibo /nfe/correcao "$RECIBO"

Cancelar NFC-e

Terminal window
RESP=$(curl -sS -X POST "$MYSE_API_BASE/nfce/cancelamento" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chave": "35260512345678000199650010000000011000000010",
"motivo": "Cancelamento de cupom solicitado pelo cliente."
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
aguardar_recibo /nfce/cancelamento "$RECIBO"

Emitir NFS-e (Nota Fiscal de Serviço)

Terminal window
RESP=$(curl -sS -X POST "$MYSE_API_BASE/nfse/emissao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"numero-origem": "OS-'$(date +%s)'",
"observacao": "Servico de consultoria realizado em maio/2026.",
"nome-contato": "Joao Silva",
"telefone-contato": "11987654321",
"data-fim": "2026-05-31",
"cliente": "12345678000199",
"itens": [
{ "produto": "SRV-CONSULT", "quantidade": "10", "valor-unitario": "250.00" }
]
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
aguardar_recibo /nfse/nota "$RECIBO"

Cancelar NFS-e

Terminal window
curl -sS -X POST "$MYSE_API_BASE/nfse/cancelamento" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chave": "chave_nfse_aqui",
"motivo": "Cancelamento solicitado pelo tomador — servico nao realizado."
}'

Reconhecer nota de fornecedor (MD-e)

Terminal window
# Códigos:
# 210200 — Confirmação da operação (terminal, irreversível)
# 210210 — Ciência da operação (provisório, 15 dias)
# 210220 — Desconhecimento da operação
# 210240 — Operação não realizada
RESP=$(curl -sS -X POST "$MYSE_API_BASE/nffornecedor/reconhecimento" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chave": "35260512345678000199550010000000011000000010",
"codigo-reconhecimento": "210200"
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
echo "Recibo MD-e: $RECIBO"
# Consultar resultado:
curl -sS "$MYSE_API_BASE/nffornecedor/$RECIBO" \
-H "Authorization: Token $MYSE_API_TOKEN" | jq .

Consulta completa por recibo

Diferente do polling rápido (/nfe/nota/{recibo}), a consulta completa traz todos os dados do documento. Veja Emitir NF-e, Emitir NFC-e e Paginação.

Terminal window
# NF-e completa: itens, cliente, transporte, faturas, notas referenciadas e dados da SEFAZ
curl -sS "$MYSE_API_BASE/nfe/nota/$RECIBO/completa" \
-H "Authorization: Token $MYSE_API_TOKEN" | jq .
# NFC-e completa: itens, cliente e dados da SEFAZ
curl -sS "$MYSE_API_BASE/nfce/cupom/$RECIBO/completa" \
-H "Authorization: Token $MYSE_API_TOKEN" | jq .
# NFC-es por path (legado): /nfce/paginacao/{pagina}/{quantidade}, pagina começa em 1
PAGINA=1
QTD=50
while :; do
RESP=$(curl -sS "$MYSE_API_BASE/nfce/paginacao/$PAGINA/$QTD" \
-H "Authorization: Token $MYSE_API_TOKEN")
[ "$(echo "$RESP" | jq -r .status)" != "005" ] && break
COUNT=$(echo "$RESP" | jq '.data | length')
echo "$RESP" | jq -c '.data[]'
[ "$COUNT" -lt "$QTD" ] && break
PAGINA=$((PAGINA + 1))
done

Inutilizar numeração

Fecha na SEFAZ uma faixa de numeração de NF-e ou NFC-e que não será usada. É assíncrona: recibo e polling. Veja Inutilizar numeração.

Terminal window
# NF-e (modelo 55) em /nfe/inutilizacao; NFC-e (modelo 65) em /nfce/inutilizacao. Mesmo corpo.
# Para um número só, repita o inicial em numero-final. "ano" (opcional) = ano em que a numeração foi gerada.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/nfe/inutilizacao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"serie": "1",
"numero-inicial": "120",
"numero-final": "125",
"justificativa": "Falha no sistema pulou a numeração da série."
}')
# 400 = recusado na hora (nota autorizada na faixa, faixa sobreposta, certificado A3...)
if [ "$(echo "$RESP" | jq -r .status)" != "001" ]; then
echo "Recusado: $(echo "$RESP" | jq -r '.data.erro // .descricao')" >&2
exit 1
fi
RECIBO=$(echo "$RESP" | jq -r .data.recibo)
aguardar_recibo /nfe/inutilizacao "$RECIBO"
# 004 = homologada (sefaz.codigo 102, com protocolo); 900 = recusada pela SEFAZ
echo "$RESP" | jq '{status, sefaz: .data.sefaz}'

XML em lote por período

Solicita o ZIP com os XMLs de NF-e ou NFC-e de um período, acompanha o protocolo e baixa o arquivo. Veja Baixar XMLs por período.

Terminal window
# tipo: "NFe" ou "NFCe". Até 92 dias por solicitação; email é opcional.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/xml/solicitacao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"tipo": "NFe",
"data-inicial": "2026-04-01",
"data-final": "2026-04-30",
"email": "[email protected]"
}')
# 001 = registrada; 050 = já havia uma igual em andamento (o protocolo é o dela, não é erro)
STATUS=$(echo "$RESP" | jq -r .status)
if [ "$STATUS" != "001" ] && [ "$STATUS" != "050" ]; then
echo "Recusado: $(echo "$RESP" | jq -r '.data.erro // .descricao')" >&2
exit 1
fi
PROTOCOLO=$(echo "$RESP" | jq -r .data.protocolo)
for i in $(seq 1 60); do
sleep 5
RESP=$(curl -sS "$MYSE_API_BASE/xml/solicitacao/$PROTOCOLO" \
-H "Authorization: Token $MYSE_API_TOKEN")
STATUS=$(echo "$RESP" | jq -r .status)
echo "[$i] status=$STATUS situacao=$(echo "$RESP" | jq -r '.data.situacao // empty')"
case "$STATUS" in
002) continue ;; # processando
005) # disponivel
URL=$(echo "$RESP" | jq -r '.data["url-download"]')
# Sem header de autenticação. A URL só aceita GET (HEAD devolve 403) e expira em data.expira-em.
curl -sS -f -o "xmls-$PROTOCOLO.zip" "$URL"
echo "Arquivo salvo em xmls-$PROTOCOLO.zip"
break ;;
006) echo "Não havia nota no período (estado final)."; break ;;
*) echo "Falha ($STATUS): $RESP" >&2; break ;; # 007 = falha final: faça NOVA solicitação
esac
done

Resumo diário

Totais por dia de NF-e e NFC-e emitidas, canceladas, denegadas e das falhas de emissão, para conciliação. Veja Resumo diário de emissões.

Terminal window
# Período máximo de 92 dias. Dias sem movimento não aparecem.
# canceladas é SUBCONJUNTO de emitidas: notas válidas = emitidas - canceladas
curl -sS "$MYSE_API_BASE/resumo?data-inicial=2026-08-01&data-final=2026-08-06" \
-H "Authorization: Token $MYSE_API_TOKEN" \
| jq -r '.data.dias[] |
"\(.data) NF-e válidas: \((.nfe.emitidas // 0) - (.nfe.canceladas // 0))" +
" NFC-e válidas: \((.nfce.emitidas // 0) - (.nfce.canceladas // 0))" +
" falhas: \(.falhas)"'

Classificação fiscal

Sugestão de NCM, CEST, CFOP, CST, alíquotas, IBS/CBS e ISS para um produto ou serviço. Responde na hora, sem recibo, e não grava nada. Veja Classificação fiscal.

Terminal window
# Pode levar alguns segundos: --max-time com folga (70 s; 90 s no lote)
RESP=$(curl -sS --max-time 70 -X POST "$MYSE_API_BASE/classificacao-fiscal" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"referencia": "SKU-NB15",
"nome": "NOTEBOOK 15 POLEGADAS 8GB RAM",
"documento": "nfe",
"destinatario": "contribuinte",
"destino": "interestadual"
}')
# 005 = classificado; 400 = motivo na descricao, campo em data.campo
echo "$RESP" | jq '{status, descricao, ncm: .data.pacote.identidade.ncm.valor, cfop: .data.pacote.icms.cfop.valor}'
# Fatos que só a empresa sabe (o pacote é snake_case)
echo "$RESP" | jq -r '.data.pacote.perguntas_pendentes[]? | "\(.id) [\(.tipo)]: \(.texto)"'
# Responda e reenvie o MESMO produto com "respostas" (valem só para esta chamada)
curl -sS --max-time 70 -X POST "$MYSE_API_BASE/classificacao-fiscal" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"referencia": "SKU-NB15",
"nome": "NOTEBOOK 15 POLEGADAS 8GB RAM",
"ncm": "8471.30.12",
"documento": "nfe",
"destinatario": "contribuinte",
"destino": "interestadual",
"respostas": {
"empresa_industrial_ou_equiparada_ipi": false,
"produto_sujeito_st_na_uf": false
}
}' | jq '.data.pacote.perguntas_pendentes'
# Lote: de 1 a 10 produtos. O envelope é 005 se o lote foi aceito: confira o status de CADA item.
curl -sS --max-time 90 -X POST "$MYSE_API_BASE/classificacao-fiscal/lote" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"produtos": [
{ "referencia": "SKU-1", "nome": "ARROZ BRANCO TIPO 1 5KG", "ncm": "1006.30.21", "documento": "nfce" },
{ "referencia": "SRV-1", "natureza": "servico", "nome": "CORTE DE CABELO MASCULINO" }
]
}' | jq -r '.data.resultados[] | "\(.indice) \(.referencia) \(.status) \(.descricao)"'

Rotinas

Uma rotina emite NFS-e sozinha em cada data da agenda (nota recorrente, aluguel, condomínio). Respondem na hora, sem recibo; quem gera recibo é cada NFS-e emitida. Veja Rotinas de emissão automática.

Terminal window
# Modelos e os campos de cada um (o "nome" de cada campo é a chave em "parametros")
curl -sS "$MYSE_API_BASE/rotinas/modelos" -H "Authorization: Token $MYSE_API_TOKEN" \
| jq -r '.data.modelos[] | "\(.codigo): \([.parametros[].nome] | join(", "))"'
# As chaves de "parametros" são os nomes dos campos do modelo (snake_case), não kebab-case.
# id_clifor e id_produto vêm de GET /rotinas/clientes?busca= e GET /rotinas/servicos.
ROTINA='{
"modelo": "NFSE_RECORRENTE",
"nome": "Suporte mensal - ACME",
"periodicidade": "mensal",
"dia": 10,
"inicio": "2026-11-01",
"parametros": {
"id_clifor": 1262804,
"id_produto": 88231,
"vl_servico": "3.500,50",
"ds_discriminacao": "Suporte técnico de {competencia}"
}
}'
# 1. Conferir sem gravar: { "pode-ativar": true, "pendencias": [] }
curl -sS -X POST "$MYSE_API_BASE/rotinas/validar" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "$ROTINA" | jq .data
# 2. Criar. Sem "ativar", ela já sai ATIVA e passa a emitir NFS-e sozinha na agenda.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/rotinas" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "$ROTINA")
ID=$(echo "$RESP" | jq -r '.data.rotina["id-rotina"]') # 400 traz data.pendencias ou data.campo
Terminal window
# 3. A agenda não emite o mês atual: emita a competência agora (corpo vazio = mês atual).
# A nota é ENFILEIRADA (numero-origem ROT-<id>-2026-11), ainda não autorizada.
curl -sS -X POST "$MYSE_API_BASE/rotinas/$ID/emitir-agora" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "competencia": "2026-11" }' | jq '{status, descricao, data}'
# 4. Histórico (mais recente primeiro): o recibo leva ao desfecho em GET /nfse/nota/{recibo}
curl -sS "$MYSE_API_BASE/rotinas/$ID/execucoes" -H "Authorization: Token $MYSE_API_TOKEN" \
| jq -r '.data.execucoes[] | "\(.competencia) \(.["situacao-descricao"]) recibo=\(.recibo // "-")"'
# 5. Pausar (só rotina ativa). Para religar: POST /rotinas/$ID/retomar
curl -sS -X POST "$MYSE_API_BASE/rotinas/$ID/pausar" \
-H "Authorization: Token $MYSE_API_TOKEN" | jq -r '.data.rotina.situacao'
Terminal window
# Detalhe: agenda, pendências e o diagnóstico (por que emitiu ou não). 005; 500 = não encontrada
curl -sS "$MYSE_API_BASE/rotinas/$ID" -H "Authorization: Token $MYSE_API_TOKEN" \
| jq '.data.rotina | {situacao, "proxima-emissao": .["proxima-emissao"], pendencias, diagnostico}'
# Alterar: todos os campos opcionais, parcial nos parâmetros (o que não vier fica como estava).
# Em rotina PAUSADA, alterar não a religa (mande "ativar": true ou use /retomar).
curl -sS -X PUT "$MYSE_API_BASE/rotinas/$ID" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "dia": 5, "parametros": { "vl_servico": 3800 } }' \
| jq '{status, descricao, campo: .data.campo, pendencias: .data.pendencias}' # 001 ou 400
# Valor extra num mês: soma à nota e ao boleto daquela competência só (rotina ativa,
# próximos meses da agenda). Os meses possíveis vêm em competencias-disponiveis.
curl -sS "$MYSE_API_BASE/rotinas/$ID/extras" -H "Authorization: Token $MYSE_API_TOKEN" \
| jq '.data | {extras, "competencias-disponiveis": .["competencias-disponiveis"]}'
curl -sS -X PUT "$MYSE_API_BASE/rotinas/$ID/extras/2026-12" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "valor": 250, "motivo": "Visita técnica extra em 02/12" }' \
| jq '{status, descricao}' # 400 = modelo não aceita extra (ex.: condomínio) ou mês fechado
# Remover o extra (não vale para mês já emitido ou em emissão)
curl -sS -X DELETE "$MYSE_API_BASE/rotinas/$ID/extras/2026-12" \
-H "Authorization: Token $MYSE_API_TOKEN" | jq '{status, descricao}'
# Excluir a rotina: 001 "Rotina excluída." com data.id-rotina
curl -sS -X DELETE "$MYSE_API_BASE/rotinas/$ID" \
-H "Authorization: Token $MYSE_API_TOKEN" | jq '{status, descricao}'

Certificado digital A1

Instala (ou troca) o certificado A1 da empresa da chave e acompanha a validade. Responde na hora, sem recibo. Desde a 3.20.0. Veja Certificado digital A1.

Terminal window
# O .pfx é binário: a API recebe o conteúdo em base64 (até 50 KB de arquivo)
# Linux
ARQUIVO=$(base64 -w0 certificado.pfx)
# macOS
ARQUIVO=$(base64 -i certificado.pfx | tr -d '\n')
# Senha em variável de ambiente exportada (ex.: vinda do seu cofre de segredos):
# export MYSE_PFX_SENHA=...
# NUNCA escreva a senha em log nem no script. O jq monta o JSON lendo o ambiente (env.*)
# e o curl lê o corpo do stdin (-d @-): nem o arquivo nem a senha vão para a linha de comando.
ARQUIVO="$ARQUIVO" jq -n '{arquivo: env.ARQUIVO, senha: env.MYSE_PFX_SENHA}' \
| curl -sS -X POST "$MYSE_API_BASE/certificado/a1" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d @- \
| jq '{status, descricao, situacao: .data.situacao, "valido-ate": .data["valido-ate"]}'
# 001 = instalado e já em uso; 400 = senha errada, não é A1 ICP-Brasil, vencido, de outro CNPJ...
# Consultar a situação (VALIDO, A_VENCER, VENCIDO, NAO_INSTALADO, INDISPONIVEL)
curl -sS "$MYSE_API_BASE/certificado" -H "Authorization: Token $MYSE_API_TOKEN" \
| jq -r '.data | "\(.situacao): validade \(.["dt-validade"]) (\(.["dias-para-vencer"]) dias)"'

CIOT

Declara na ANTT a operação de transporte e devolve o código do CIOT. É assíncrono: recibo e polling, também nos eventos. Veja Emitir CIOT.

Terminal window
# Os campos seguem o leiaute PEF da ANTT (PascalCase), exceção ao kebab-case da v3.
# Não envie CpfCnpjContratado, RNTRCContratado nem IdOperacaoTransporte: vêm do cadastro.
# numero-origem estável por viagem: depois de um 999, reenvie com o MESMO valor.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/ciot/emissao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"numero-origem": "VIAGEM-2026-1021",
"TipoOperacao": 1,
"CpfCnpjContratante": "12345678000199",
"CpfCnpjDestinatario": "98765432000155",
"ValorFrete": 1500.00,
"Veiculos": [ { "Placa": "ABC1D23", "NumeroEixos": "4" } ],
"OrigemDestino": [ {
"Origem": { "CodigoMunicipioOrigem": 4127700 },
"Destino": { "CodigoMunicipioDestino": 4104808 },
"DistanciaPercorrida": 45
} ],
"DadosCarga": { "CodigoNaturezaCarga": 9999, "CodigoTipoCarga": 5, "PesoCarga": 1000 },
"InfIndicadoresOperacionais": {
"IndAltoDesempenho": false, "IndRetornoVazio": false, "ComposicaoVeicular": false
},
"InfPagamento": [ { "TipoPagamento": 6, "IndPagamento": 0,
"ChavePix": "[email protected]",
"IdentificadorPix": "FRETE-2026-1021" } ]
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo) # 400 = recusado na hora, motivo em data.erro
aguardar_recibo /ciot "$RECIBO"
# 004 = emitido; 900 = recusado (data.erro ou data.antt.mensagem)
CIOT=$(echo "$RESP" | jq -r .data.ciot)
echo "$RESP" | jq '.data | {situacao, ciot, "codigo-verificador": .["codigo-verificador"], protocolo}'
# Encerrar ao fim da viagem (por "ciot" ou pelo "recibo" da emissão). O evento tem recibo próprio.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/ciot/encerramento" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "{ \"ciot\": \"$CIOT\" }")
aguardar_recibo /ciot "$(echo "$RESP" | jq -r .data.recibo)" # 004 = encerrado
Terminal window
# Retificar: só carga FRACIONADA (TipoOperacao 2); lotação não admite (cancele e emita outro).
# Informe ao menos um campo; CodigoMunicipioOrigem e CodigoMunicipioDestino vão juntos.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/ciot/retificacao" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "{ \"ciot\": \"$CIOT\", \"ValorFrete\": 1650.00, \"PesoCarga\": 1200 }")
aguardar_recibo /ciot "$(echo "$RESP" | jq -r .data.recibo)" # 004 = retificado; 900 = recusado
# Cancelar (por "ciot" ou pelo "recibo" da emissão). motivo obrigatório, até 500 caracteres.
# CIOT REJEITADO pela ANTT só é marcado como cancelado no FazNota, sem chamar a ANTT.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/ciot/cancelamento" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "{ \"ciot\": \"$CIOT\", \"motivo\": \"Viagem cancelada pelo contratante.\" }")
aguardar_recibo /ciot "$(echo "$RESP" | jq -r .data.recibo)" # 010 = cancelado

RENAVE

Registra no RENAVE (SERPRO) a entrada e a saída de veículos do estoque da revenda, vinculadas à NF-e da operação. É assíncrono. Veja RENAVE.

Terminal window
# Os campos seguem o leiaute do SERPRO (camelCase), exceção ao kebab-case da v3.
# chaveNFe = NF-e modelo 55 de entrada, emitida pela própria empresa.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/renave/nota-fiscal/entrada" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chaveNFe": "35261012345678000190550010000012341000012345",
"cpfOperadorResponsavel": "12345678901",
"dataCompra": "2026-10-20",
"valorCompra": 45000.00,
"emailVendedor": "[email protected]",
"veiculo": {
"placa": "ABC1D23",
"numeroCrv": "123456789012",
"renavam": "01234567890",
"codigoSegurancaCrv": "12345678901",
"tipoCrv": "DIGITAL",
"dataHoraMedicaoHodometro": "2026-10-20T10:00:00",
"quilometragemHodometro": 52000,
"documentoProprietarioAtual": "98765432100",
"tipoDocumentoProprietarioAtual": "CPF"
}
}')
RECIBO=$(echo "$RESP" | jq -r .data.recibo) # 400 = recusado na hora, motivo em data.erro
# > /dev/null: o helper imprime a resposta inteira, e a do RENAVE tem dados pessoais
aguardar_recibo /renave "$RECIBO" > /dev/null # 002 na fila, 003 sendo enviado ao SERPRO
# 004 = registrado; 900 = recusado (data.mensagem ou data.erro); 999 = reenvie o MESMO pedido
# Guarde o id-renave: ele identifica o registro no cancelamento.
echo "$RESP" | jq '{status, "id-renave": .data["id-renave"], "id-estoque": .data["id-estoque"]}'

O resultado de qualquer operação RENAVE sai em GET /renave/{recibo}. A resposta traz dados pessoais (CPF, endereço do comprador): não grave a resposta inteira em log, leia só os campos de que precisa.

Terminal window
# Consulta pontual de um recibo, sem despejar o corpo:
# 004 registrado (id-renave, id-estoque) · 010 cancelado · 900 recusado · 002/003 em andamento
# 999 erro técnico (reenvie o MESMO pedido) · 500 recibo inexistente
curl -sS "$MYSE_API_BASE/renave/$RECIBO" -H "Authorization: Token $MYSE_API_TOKEN" \
| jq '{status, descricao, "id-renave": .data["id-renave"], motivo: (.data.mensagem // .data.erro)}'
Terminal window
# Saída do estoque (venda), vinculada à NF-e de venda modelo 55
RESP=$(curl -sS -X POST "$MYSE_API_BASE/renave/nota-fiscal/saida" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chaveNFe": "35261012345678000190550010000012351000012356",
"cpfOperadorResponsavel": "12345678901",
"dataVenda": "2026-10-25",
"valorVenda": 52000.00,
"veiculo": { "placa": "ABC1D23", "numeroCrv": "123456789012", "renavam": "01234567890" },
"comprador": {
"nome": "Maria Souza",
"email": "[email protected]",
"tipoDocumento": "CPF",
"numeroDocumento": "98765432100",
"endereco": {
"logradouro": "Av. Paulista", "numero": "1000", "bairro": "Bela Vista",
"cep": "01310100", "municipio": "São Paulo", "uf": "SP"
}
}
}')
RECIBO_SAIDA=$(echo "$RESP" | jq -r .data.recibo)
aguardar_recibo /renave "$RECIBO_SAIDA" > /dev/null
echo "$RESP" | jq '{status, "id-renave": .data["id-renave"], motivo: (.data.mensagem // .data.erro)}'
# Entrada de veículo PRÓPRIO (sem compra). A chaveNFe identifica o movimento no FazNota e não
# vai ao SERPRO. Aqui codigoSegurancaCrv, tipoCrv e o hodômetro também são obrigatórios.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/renave/estoque/entrada-veiculo-proprio" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"chaveNFe": "35261012345678000190550010000012361000012367",
"cpfOperadorResponsavel": "12345678901",
"dataEntradaEstoque": "2026-10-20",
"veiculo": {
"placa": "DEF4G56",
"numeroCrv": "223456789012",
"renavam": "11234567890",
"codigoSegurancaCrv": "22345678901",
"tipoCrv": "DIGITAL",
"dataHoraMedicaoHodometro": "2026-10-20T09:00:00",
"quilometragemHodometro": 18000
}
}')
aguardar_recibo /renave "$(echo "$RESP" | jq -r .data.recibo)" > /dev/null
echo "$RESP" | jq '{status, "id-renave": .data["id-renave"], motivo: (.data.mensagem // .data.erro)}'
Terminal window
# Cancelar uma entrada (compra ou veículo próprio) ou uma saída registrada com sucesso.
# Identifique por "id-renave" OU pelo "recibo" do registro; os dados do veículo vêm do registro.
RESP=$(curl -sS -X POST "$MYSE_API_BASE/renave/estoque/cancelamento-entrada" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "{ \"recibo\": \"$RECIBO\" }")
aguardar_recibo /renave "$(echo "$RESP" | jq -r .data.recibo)" > /dev/null
echo "$RESP" | jq '{status, motivo: (.data.mensagem // .data.erro)}' # 010 = cancelado
RESP=$(curl -sS -X POST "$MYSE_API_BASE/renave/estoque/cancelamento-saida" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d "{ \"recibo\": \"$RECIBO_SAIDA\" }")
aguardar_recibo /renave "$(echo "$RESP" | jq -r .data.recibo)" > /dev/null
echo "$RESP" | jq '{status, motivo: (.data.mensagem // .data.erro)}' # 010 = cancelado

Capturar headers de rate limit

Terminal window
curl -sS -D - "$MYSE_API_BASE/nfe?page=1&page_size=1" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-o /dev/null \
| grep -i -E "x-request-id|x-ratelimit"

Saída esperada:

X-Request-Id: req_01HXY8ZG3J4K5M6N7P8Q9R0S1T
X-RateLimit-Limit: 150000
X-RateLimit-Remaining: 149873
X-RateLimit-Reset: 1715600000

Tratamento de erro em shell

Terminal window
call_api() {
local METHOD="$1"
local API_PATH="$2" # não use PATH: sobrescreve o PATH do shell
local BODY="${3:-}"
local CURL_ARGS=(-sS -X "$METHOD"
-H "Authorization: Token $MYSE_API_TOKEN"
-H "Content-Type: application/json"
-D /tmp/myse-headers.txt)
[ -n "$BODY" ] && CURL_ARGS+=(-d "$BODY")
RESP=$(curl "${CURL_ARGS[@]}" "$MYSE_API_BASE$API_PATH")
REQ_ID=$(grep -i "x-request-id:" /tmp/myse-headers.txt | awk '{print $2}' | tr -d '\r\n')
STATUS=$(echo "$RESP" | jq -r .status)
case "$STATUS" in
001|002|003|004|005|010)
echo "$RESP"
;;
050)
echo "Duplicidade (use recibo retornado): $RESP" >&2
echo "$RESP"
;;
900)
echo "Rejeição SEFAZ (request_id=$REQ_ID): $RESP" >&2
exit 2
;;
999)
echo "Erro interno (request_id=$REQ_ID): $RESP" >&2
exit 3
;;
*)
echo "Status desconhecido $STATUS (request_id=$REQ_ID): $RESP" >&2
exit 99
;;
esac
}

Health check (sem autenticação)

Terminal window
curl -i "$MYSE_API_BASE/health"
# HTTP/1.1 200 OK
# {"status":"ok","database":"ok","timestamp":"2026-05-13T14:32:01Z"}
# Profundo: SELECT 1 no banco + pool de conexões. 200 = UP; 503 = banco falhou ou pool saturado
curl -sS -o /tmp/myse-deep.json -w '%{http_code}\n' "$MYSE_API_BASE/health/deep"
jq '{status, total_ms, db, pool}' /tmp/myse-deep.json
# Só as métricas do pool, sem tocar no banco (sempre 200; status STARTING enquanto inicializa)
curl -sS "$MYSE_API_BASE/health/pool" \
| jq -r '"\(.status) ativas=\(.pool.active) ociosas=\(.pool.idle) esperando=\(.pool.waiting) max=\(.pool.max)"'

Alterar nota antes da emissão (PUT)

Disponível em NF-e (/nfe/{id}), NFC-e (/nfce/{id}) e NFS-e (/nfse/{id}). Só funciona enquanto a nota ainda não foi submetida para emissão.

Terminal window
# Substitua o caminho e o ID conforme o documento
curl -X PUT "$MYSE_API_BASE/nfe/12345" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"serie": "1",
"cfop": "5102",
"cliente": "12345678000199",
"itens": [
{ "produto": "SKU-001", "quantidade": "3", "valor-unitario": "89.90" }
]
}'

Listagens (paginação)

Terminal window
# NF-es paginadas
curl "$MYSE_API_BASE/nfe?page=1&page_size=20" \
-H "Authorization: Token $MYSE_API_TOKEN"
# NFC-es
curl "$MYSE_API_BASE/nfce?page=1&page_size=50" \
-H "Authorization: Token $MYSE_API_TOKEN"
# NFS-es com filtro de data (ISO YYYY-MM-DD)
curl "$MYSE_API_BASE/nfse?dataInicial=2026-05-01&page=1&page_size=20" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Notas de fornecedor
curl "$MYSE_API_BASE/nffornecedor?page=1&page_size=20" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Forma legada (path-based) — mantida por compatibilidade
curl "$MYSE_API_BASE/nfe/paginacao/1/20" \
-H "Authorization: Token $MYSE_API_TOKEN"

Clientes (CRUD completo)

Terminal window
# Cadastrar pessoa física
curl -X POST "$MYSE_API_BASE/clientes" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"tipo": "F",
"nome": "Joao da Silva",
"cpf": "12345678901",
"rg": "MG1234567",
"consumidor-final": "1",
"contato": { "email": "[email protected]", "telefone": "11987654321" },
"endereco": {
"cep": "01310100", "rua": "Av. Paulista", "numero": "1000",
"bairro": "Bela Vista", "cidade": "Sao Paulo", "estado": "SP"
}
}'
# Cadastrar pessoa jurídica
curl -X POST "$MYSE_API_BASE/clientes" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"tipo": "J",
"razao-social": "Empresa Exemplo Ltda",
"nome-fantasia": "Empresa Exemplo",
"cnpj": "12345678000199",
"inscricao-municipal": "1234567",
"tipo-inscricao-estadual": "1",
"inscricao-estadual": "123456789",
"consumidor-final": "0",
"contato": { "email": "[email protected]", "telefone": "1133334444" },
"endereco": {
"cep": "01310100", "rua": "Av. Paulista", "numero": "1000",
"bairro": "Bela Vista", "cidade": "Sao Paulo", "estado": "SP"
}
}'
# Consultar por CPF (11 dígitos) ou CNPJ (14 dígitos)
curl "$MYSE_API_BASE/clientes/12345678000199" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Buscar por nome (parcial)
curl "$MYSE_API_BASE/clientes/busca/exemplo" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Top 20 clientes mais relevantes da empresa
curl "$MYSE_API_BASE/clientes/busca/top_clientes" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Atualizar
curl -X PUT "$MYSE_API_BASE/clientes/12345678000199" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "tipo": "J", "razao-social": "Empresa Exemplo (Novo Nome) Ltda" }'
# Excluir
curl -X DELETE "$MYSE_API_BASE/clientes/12345678000199" \
-H "Authorization: Token $MYSE_API_TOKEN"

Produtos (CRUD completo)

Terminal window
# Cadastrar produto (com configuração fiscal por CFOP/estado)
curl -X POST "$MYSE_API_BASE/produtos" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"referencia": "SKU-001",
"nome": "Camiseta Polo Tamanho M",
"valor": "89.90",
"medida": "UN",
"categoria": "Vestuario",
"ncm": "61051000",
"origem": "0",
"cfop-preferencial": "5102",
"tipo-produto": "P",
"configuracoes-fiscais": [{
"cfop": "5102",
"configuracoes": {
"ipi": { "ipi-cst": "53", "ipi-aliquota": "0.00" },
"pis-cofins": {
"pis-cst": "01", "pis-aliquota": "1.65",
"cofins-cst": "01", "cofins-aliquota": "7.60"
},
"icms": {
"estados": [{
"estado": "SP",
"icms-cst": "00",
"modalidade-base-calculo": "0",
"aliquotas": { "aliquota-icms": "18.00" }
}]
}
}
}]
}'
# Cadastrar serviço (tipo S, com código de serviço municipal)
curl -X POST "$MYSE_API_BASE/produtos" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"referencia": "SRV-CONSULT",
"nome": "Consultoria tecnica (hora)",
"valor": "250.00",
"medida": "H",
"tipo-produto": "S",
"codigo-servico": "1.04"
}'
# Consultar por referência
curl "$MYSE_API_BASE/produtos/SKU-001" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Buscar por nome (1º resultado)
curl "$MYSE_API_BASE/produtos/nome/Camiseta" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Listar paginado com busca por nome (legado)
# Use _todos para não filtrar
curl "$MYSE_API_BASE/produtos/paginacao/1/20/_todos" \
-H "Authorization: Token $MYSE_API_TOKEN"
curl "$MYSE_API_BASE/produtos/paginacao/1/20/Camiseta" \
-H "Authorization: Token $MYSE_API_TOKEN"
# Atualizar
curl -X PUT "$MYSE_API_BASE/produtos/SKU-001" \
-H "Authorization: Token $MYSE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "referencia": "SKU-001", "nome": "Camiseta Polo M (Novo)", "valor": "99.90" }'
# Excluir
curl -X DELETE "$MYSE_API_BASE/produtos/SKU-001" \
-H "Authorization: Token $MYSE_API_TOKEN"