Pular para o conteúdo

Exemplos em Go

Setup

Requer Go 1.21+. Sem dependências externas (usa stdlib).

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

Cliente HTTP centralizado

package myse
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"time"
)
type ApiResponse struct {
Status string `json:"status"`
Descricao string `json:"descricao"`
Data json.RawMessage `json:"data,omitempty"`
Meta *Meta `json:"meta,omitempty"`
}
type Meta struct {
RequestID string `json:"request_id"`
Timestamp string `json:"timestamp"`
}
type ApiError struct {
HTTPStatus int
Message string
Payload json.RawMessage
RequestID string
}
func (e *ApiError) Error() string {
return fmt.Sprintf("[%d] %s (request_id=%s)", e.HTTPStatus, e.Message, e.RequestID)
}
type Client struct {
Base string
Token string
HTTP *http.Client
}
func New() *Client {
return &Client{
Base: os.Getenv("MYSE_API_BASE"),
Token: os.Getenv("MYSE_API_TOKEN"),
HTTP: &http.Client{Timeout: 30 * time.Second},
}
}
func (c *Client) Call(ctx context.Context, method, path string, body any) (*ApiResponse, error) {
var reader io.Reader
if body != nil {
b, err := json.Marshal(body)
if err != nil {
return nil, err
}
reader = bytes.NewReader(b)
}
req, err := http.NewRequestWithContext(ctx, method, c.Base+path, reader)
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Token "+c.Token)
req.Header.Set("Content-Type", "application/json")
res, err := c.HTTP.Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
bodyBytes, _ := io.ReadAll(res.Body)
requestID := res.Header.Get("X-Request-Id")
if res.StatusCode >= 400 {
return nil, &ApiError{
HTTPStatus: res.StatusCode,
Message: fmt.Sprintf("HTTP %d", res.StatusCode),
Payload: bodyBytes,
RequestID: requestID,
}
}
var apiResp ApiResponse
if err := json.Unmarshal(bodyBytes, &apiResp); err != nil {
return nil, err
}
if apiResp.Status == "999" {
// Extrai erro do data
var data map[string]any
json.Unmarshal(apiResp.Data, &data)
msg, _ := data["erro"].(string)
if msg == "" {
msg = apiResp.Descricao
}
rid := requestID
if apiResp.Meta != nil && apiResp.Meta.RequestID != "" {
rid = apiResp.Meta.RequestID
}
return nil, &ApiError{HTTPStatus: 200, Message: msg, Payload: bodyBytes, RequestID: rid}
}
return &apiResp, nil
}

Cenário: emitir NFCe com polling

package main
import (
"context"
"encoding/json"
"fmt"
"math"
"time"
)
var terminais = map[string]bool{"004": true, "010": true, "900": true, "999": true}
func EmitirNFCe(ctx context.Context, c *myse.Client, pedido Pedido) (json.RawMessage, error) {
body := map[string]any{
"serie": "65",
"cfop": "5102",
"numero-origem": fmt.Sprintf("PED-%d", pedido.ID),
"tp_pagamento": pedido.FormaPagamento,
"cliente": pedido.CpfCnpjCliente,
"itens": buildItens(pedido.Itens),
}
emissao, err := c.Call(ctx, "POST", "/nfce/emissao", body)
if err != nil {
return nil, err
}
if emissao.Status != "001" && emissao.Status != "050" {
return nil, fmt.Errorf("emissão falhou: %s", emissao.Descricao)
}
var emissaoData map[string]string
json.Unmarshal(emissao.Data, &emissaoData)
recibo := emissaoData["recibo"]
fmt.Printf("[emissao] recibo=%s request_id=%s\n", recibo, emissao.Meta.RequestID)
wait := 5 * time.Second
deadline := time.Now().Add(5 * time.Minute)
for time.Now().Before(deadline) {
time.Sleep(wait)
consulta, err := c.Call(ctx, "GET", "/nfce/cupom/"+recibo, nil)
if err != nil {
return nil, err
}
fmt.Printf("[polling] status=%s\n", consulta.Status)
if terminais[consulta.Status] {
if consulta.Status == "004" {
return consulta.Data, nil
}
return nil, fmt.Errorf("status terminal não-sucesso: %s", consulta.Status)
}
wait = time.Duration(math.Min(float64(wait)*1.5, float64(30*time.Second)))
}
return nil, fmt.Errorf("timeout aguardando recibo %s", recibo)
}
func buildItens(itens []Item) []map[string]string {
out := make([]map[string]string, len(itens))
for i, it := range itens {
out[i] = map[string]string{
"produto": it.SKU,
"quantidade": fmt.Sprintf("%d", it.Qtd),
"valor-unitario": fmt.Sprintf("%.2f", it.Preco),
}
}
return out
}

Retry com backoff

func ComRetry[T any](ctx context.Context, fn func() (T, error), max int) (T, error) {
var zero T
var lastErr error
for i := 1; i <= max; i++ {
result, err := fn()
if err == nil {
return result, nil
}
// Erros de validação: não retentar
if apiErr, ok := err.(*myse.ApiError); ok {
var p map[string]any
json.Unmarshal(apiErr.Payload, &p)
if p["status"] == "999" {
return zero, err
}
}
lastErr = err
if i < max {
time.Sleep(time.Duration(math.Pow(2, float64(i-1))) * time.Second)
}
}
return zero, lastErr
}

Helper de polling reutilizável

var terminais = map[string]bool{"004": true, "010": true, "900": true, "999": true}
func AguardarRecibo(ctx context.Context, c *myse.Client, pathBase, recibo string, timeout time.Duration) (*myse.ApiResponse, error) {
if timeout == 0 {
timeout = 5 * time.Minute
}
wait := 5 * time.Second
inicio := time.Now()
for time.Since(inicio) < timeout {
time.Sleep(wait)
resp, err := c.Call(ctx, "GET", pathBase+"/"+recibo, nil)
if err != nil {
return nil, err
}
if terminais[resp.Status] {
return resp, nil
}
wait = time.Duration(math.Min(float64(wait)*1.5, float64(30*time.Second)))
}
return nil, fmt.Errorf("timeout aguardando recibo %s", recibo)
}
func validarMotivo(motivo string) error {
if len(motivo) < 15 || len(motivo) > 255 {
return fmt.Errorf("motivo deve ter entre 15 e 255 caracteres")
}
return nil
}
// Texto da carta de correção (POST /nfe/correcao): 15 a 1000 caracteres desde a 3.15.1.
// Conta caracteres (runas), não bytes: acento ocupa 2 bytes em UTF-8. import "unicode/utf8"
func validarTextoCorrecao(texto string) error {
if n := utf8.RuneCountInString(texto); n < 15 || n > 1000 {
return fmt.Errorf("texto da correção deve ter entre 15 e 1000 caracteres")
}
return nil
}

Emitir NF-e (com transporte completo)

func EmitirNFe(ctx context.Context, c *myse.Client, pedido Pedido) (json.RawMessage, error) {
faturas := make([]map[string]string, 0, len(pedido.Faturas))
for _, f := range pedido.Faturas {
faturas = append(faturas, map[string]string{
"valor": fmt.Sprintf("%.2f", f.Valor),
"data": f.Data,
})
}
body := map[string]any{
"serie": "1",
"cfop": "5102",
"numero-origem": fmt.Sprintf("PED-%d", pedido.ID),
"tipo": "S",
"finalidade": "N",
"valor-despesas": "0.00",
"cliente": pedido.CpfCnpjCliente,
"transporte": map[string]string{
"modalidade": "0",
"transportadora": pedido.Transportadora,
"placa-veiculo": pedido.Placa,
"valor-frete": pedido.Frete,
"valor-seguro": "0.00",
"peso-bruto": pedido.PesoBruto,
"peso-liquido": pedido.PesoLiquido,
"quantidade-volume": "1",
"especie-volume": "Caixa",
"marca-volume": "Embalagem",
},
"itens": buildItens(pedido.Itens),
"faturas": faturas,
}
emissao, err := c.Call(ctx, "POST", "/nfe/emissao", body)
if err != nil {
return nil, err
}
if emissao.Status != "001" && emissao.Status != "050" {
return nil, fmt.Errorf("emissão falhou: %s", emissao.Descricao)
}
var d map[string]string
json.Unmarshal(emissao.Data, &d)
resultado, err := AguardarRecibo(ctx, c, "/nfe/nota", d["recibo"], 0)
if err != nil {
return nil, err
}
if resultado.Status != "004" {
return nil, fmt.Errorf("status terminal não-sucesso: %s", resultado.Status)
}
return resultado.Data, nil // inclui sefaz.chave, url-danfe, url-xml
}

Cancelar NF-e

func CancelarNFe(ctx context.Context, c *myse.Client, chave, motivo string) (*myse.ApiResponse, error) {
if err := validarMotivo(motivo); err != nil {
return nil, err
}
cancel, err := c.Call(ctx, "POST", "/nfe/cancelamento", map[string]string{
"chave": chave,
"motivo": motivo,
})
if err != nil {
return nil, err
}
if cancel.Status != "001" {
return nil, errors.New(cancel.Descricao)
}
var d map[string]string
json.Unmarshal(cancel.Data, &d)
return AguardarRecibo(ctx, c, "/nfe/cancelamento", d["recibo"], 0)
}

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

// O campo "motivo" na CC-e é o TEXTO da correção (xCorrecao): 15 a 1000 caracteres.
// (O motivo do cancelamento continua entre 15 e 255.)
func CartaCorrecaoNFe(ctx context.Context, c *myse.Client, chave, textoCorrecao string) (*myse.ApiResponse, error) {
if err := validarTextoCorrecao(textoCorrecao); err != nil {
return nil, err
}
cce, err := c.Call(ctx, "POST", "/nfe/correcao", map[string]string{
"chave": chave,
"motivo": textoCorrecao,
})
if err != nil {
return nil, err
}
if cce.Status != "001" {
return nil, errors.New(cce.Descricao)
}
var d map[string]string
json.Unmarshal(cce.Data, &d)
return AguardarRecibo(ctx, c, "/nfe/correcao", d["recibo"], 0)
}

Cancelar NFC-e

func CancelarNFCe(ctx context.Context, c *myse.Client, chave, motivo string) (*myse.ApiResponse, error) {
if err := validarMotivo(motivo); err != nil {
return nil, err
}
cancel, err := c.Call(ctx, "POST", "/nfce/cancelamento", map[string]string{
"chave": chave,
"motivo": motivo,
})
if err != nil {
return nil, err
}
if cancel.Status != "001" {
return nil, errors.New(cancel.Descricao)
}
var d map[string]string
json.Unmarshal(cancel.Data, &d)
return AguardarRecibo(ctx, c, "/nfce/cancelamento", d["recibo"], 0)
}

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

func EmitirNFSe(ctx context.Context, c *myse.Client, servico Servico) (json.RawMessage, error) {
itens := make([]map[string]string, 0, len(servico.Itens))
for _, i := range servico.Itens {
itens = append(itens, map[string]string{
"produto": i.CodigoServico,
"quantidade": fmt.Sprintf("%d", i.Qtd),
"valor-unitario": fmt.Sprintf("%.2f", i.Preco),
})
}
body := map[string]any{
"numero-origem": fmt.Sprintf("OS-%d", servico.ID),
"observacao": servico.Observacao,
"nome-contato": servico.NomeContato,
"telefone-contato": servico.TelefoneContato,
"data-fim": servico.DataFim,
"cliente": servico.CpfCnpjCliente,
"itens": itens,
}
emissao, err := c.Call(ctx, "POST", "/nfse/emissao", body)
if err != nil {
return nil, err
}
if emissao.Status != "001" && emissao.Status != "050" {
return nil, fmt.Errorf("emissão NFSe falhou: %s", emissao.Descricao)
}
var d map[string]string
json.Unmarshal(emissao.Data, &d)
resultado, err := AguardarRecibo(ctx, c, "/nfse/nota", d["recibo"], 0)
if err != nil {
return nil, err
}
if resultado.Status != "004" {
return nil, fmt.Errorf("status terminal não-sucesso: %s", resultado.Status)
}
return resultado.Data, nil
}

Cancelar NFS-e

func CancelarNFSe(ctx context.Context, c *myse.Client, chave, motivo string) (*myse.ApiResponse, error) {
if err := validarMotivo(motivo); err != nil {
return nil, err
}
return c.Call(ctx, "POST", "/nfse/cancelamento", map[string]string{
"chave": chave,
"motivo": motivo,
})
}

Reconhecer nota de fornecedor (MD-e)

// Códigos de reconhecimento:
// "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
func ReconhecerNotaFornecedor(ctx context.Context, c *myse.Client, chave, codigo string) (*myse.ApiResponse, error) {
validos := map[string]bool{"210200": true, "210210": true, "210220": true, "210240": true}
if !validos[codigo] {
return nil, fmt.Errorf("código inválido: %s", codigo)
}
resp, err := c.Call(ctx, "POST", "/nffornecedor/reconhecimento", map[string]string{
"chave": chave,
"codigo-reconhecimento": codigo,
})
if err != nil {
return nil, err
}
if resp.Status != "001" {
return nil, errors.New(resp.Descricao)
}
var d map[string]string
json.Unmarshal(resp.Data, &d)
return AguardarRecibo(ctx, c, "/nffornecedor", d["recibo"], 0)
}

Consulta completa por recibo

Para o polling, a consulta simples (/nfe/nota/{recibo}, /nfce/cupom/{recibo}) basta. A versão /completa traz o documento inteiro: itens, cliente e dados da SEFAZ e, na NF-e, também transporte, faturas e notas referenciadas. Veja Emitir NF-e e Emitir NFC-e.

nfeCompleta, _ := c.Call(ctx, "GET", "/nfe/nota/"+recibo+"/completa", nil)
nfceCompleta, _ := c.Call(ctx, "GET", "/nfce/cupom/"+recibo+"/completa", nil)
// NFC-e paginadas pelo path (forma legada): página 1, 50 por página (máximo 500)
cupons, _ := c.Call(ctx, "GET", "/nfce/paginacao/1/50", nil)

Inutilizar numeração

Fecha na SEFAZ um buraco na numeração de NF-e ou NFC-e. É assíncrona, como a emissão. Veja Inutilizar numeração.

// tipo: "nfe" (modelo 55) ou "nfce" (modelo 65). O corpo é o mesmo.
func Inutilizar(ctx context.Context, c *myse.Client, tipo, serie, inicial, final, justificativa string) (json.RawMessage, error) {
if err := validarMotivo(justificativa); err != nil { // mesma regra: 15 a 255 caracteres
return nil, err
}
pedido, err := c.Call(ctx, "POST", "/"+tipo+"/inutilizacao", map[string]string{
"serie": serie,
"numero-inicial": inicial,
"numero-final": final, // igual ao inicial para um número só
"justificativa": justificativa,
// "ano": "2025": informe quando a numeração foi gerada em outro ano
})
if err != nil {
return nil, err
}
if pedido.Status != "001" {
// 400: recusado na hora (número autorizado na faixa, faixa já na fila, certificado A3...)
return nil, fmt.Errorf("inutilização recusada: %s", pedido.Descricao)
}
var d struct {
Recibo string `json:"recibo"`
}
json.Unmarshal(pedido.Data, &d)
resultado, err := AguardarRecibo(ctx, c, "/"+tipo+"/inutilizacao", d.Recibo, 0)
if err != nil {
return nil, err
}
if resultado.Status != "004" { // 900: a SEFAZ recusou; motivo em data.sefaz.codigo/mensagem
return nil, fmt.Errorf("inutilização recusada pela SEFAZ: %s", resultado.Data)
}
return resultado.Data, nil // sefaz.codigo 102 e sefaz.protocolo da homologação
}

XML em lote por período

Pede o ZIP com os XMLs de NF-e ou NFC-e de um período (até 92 dias), consulta o protocolo e baixa o arquivo do link temporário. Veja Baixar XMLs por período.

// Devolve false (sem erro) quando não havia nota no período.
func BaixarXmlPeriodo(ctx context.Context, c *myse.Client, tipo, dataInicial, dataFinal, destino string) (bool, error) {
pedido, err := c.Call(ctx, "POST", "/xml/solicitacao", map[string]string{
"tipo": tipo, // "NFe" ou "NFCe"
"data-inicial": dataInicial, // AAAA-MM-DD
"data-final": dataFinal,
"email": "[email protected]",
})
if err != nil {
return false, err
}
if pedido.Status != "001" && pedido.Status != "050" { // 050 = já havia uma solicitação igual em andamento
return false, fmt.Errorf("solicitação recusada: %s", pedido.Descricao)
}
var d struct {
Protocolo string `json:"protocolo"`
}
json.Unmarshal(pedido.Data, &d)
// Os status aqui não são os da nota: 005 pronto; 006 (sem notas) e 007 (falha) são finais
wait := 2 * time.Second
deadline := time.Now().Add(15 * time.Minute)
for time.Now().Before(deadline) {
time.Sleep(wait)
consulta, err := c.Call(ctx, "GET", "/xml/solicitacao/"+d.Protocolo, nil)
if err != nil {
return false, err
}
switch consulta.Status {
case "002": // processando
case "005":
var pronto struct {
URL string `json:"url-download"`
}
json.Unmarshal(consulta.Data, &pronto)
return true, baixarArquivo(ctx, pronto.URL, destino)
case "006":
return false, nil
default: // 007 falha (faça nova solicitação), 500 protocolo inexistente
return false, fmt.Errorf("solicitação %s: %s", d.Protocolo, consulta.Descricao)
}
wait = time.Duration(math.Min(float64(wait)*1.5, float64(30*time.Second)))
}
return false, fmt.Errorf("timeout aguardando protocolo %s", d.Protocolo)
}
// Link temporário: só GET (HEAD devolve 403) e SEM o header Authorization
func baixarArquivo(ctx context.Context, url, destino string) error {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return err
}
res, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return fmt.Errorf("download falhou: HTTP %d", res.StatusCode)
}
f, err := os.Create(destino)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, res.Body)
return err
}

Resumo diário

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

type Contagem struct {
Emitidas int `json:"emitidas"`
Canceladas int `json:"canceladas"` // DENTRO de emitidas: nunca some os dois
Denegadas int `json:"denegadas"` // só NF-e
}
type Resumo struct {
Dias []struct { // dias sem movimento não aparecem
Data string `json:"data"`
NFe Contagem `json:"nfe"`
NFCe Contagem `json:"nfce"`
Falhas map[string]int `json:"falhas"` // nfe, nfce, nfse
} `json:"dias"`
Totais struct {
NFe Contagem `json:"nfe"`
NFCe Contagem `json:"nfce"`
Falhas int `json:"falhas"`
} `json:"totais"`
}
func ResumoPeriodo(ctx context.Context, c *myse.Client, inicio, fim string) (*Resumo, error) {
resp, err := c.Call(ctx, "GET", "/resumo?data-inicial="+inicio+"&data-final="+fim, nil)
if err != nil {
return nil, err
}
var r Resumo
if err := json.Unmarshal(resp.Data, &r); err != nil {
return nil, err
}
for _, dia := range r.Dias {
fmt.Printf("%s NF-e válidas=%d NFC-e emitidas=%d falhas NFC-e=%d\n",
dia.Data, dia.NFe.Emitidas-dia.NFe.Canceladas, dia.NFCe.Emitidas, dia.Falhas["nfce"])
}
return &r, nil
}

Classificação fiscal

Sugestão de NCM, CFOP, CST, alíquotas e IBS/CBS de um produto ou serviço, na mesma chamada (sem recibo). É uma sugestão: confira com o contador antes de emitir. Veja Classificação fiscal.

// Timeout com folga: 70 s no individual, 90 s no lote (o padrão do cliente é 30 s)
func clienteLento(c *myse.Client) *myse.Client {
lento := *c
lento.HTTP = &http.Client{Timeout: 90 * time.Second}
return &lento
}
type Pergunta struct {
ID string `json:"id"`
Texto string `json:"texto"`
Tipo string `json:"tipo"` // booleano, escolha ou texto
}
// O pacote tem chaves em snake_case (perguntas_pendentes, cst_csosn).
func Classificar(ctx context.Context, c *myse.Client, produto map[string]any) (json.RawMessage, []Pergunta, error) {
resp, err := clienteLento(c).Call(ctx, "POST", "/classificacao-fiscal", produto)
if err != nil {
return nil, nil, err
}
var d struct {
Campo string `json:"campo"`
Pacote json.RawMessage `json:"pacote"`
}
json.Unmarshal(resp.Data, &d)
if resp.Status != "005" { // 400: corrija o campo indicado; repetir igual não resolve
return nil, nil, fmt.Errorf("%s (campo: %s)", resp.Descricao, d.Campo)
}
var p struct {
Pendentes []Pergunta `json:"perguntas_pendentes"`
}
json.Unmarshal(d.Pacote, &p)
return d.Pacote, p.Pendentes, nil
}
// Uso: responda às perguntas e reenvie o MESMO produto, com todas as respostas
produto := map[string]any{
"referencia": "SKU-NB15",
"nome": "NOTEBOOK 15 POLEGADAS 8GB RAM",
"ncm": "8471.30.12", // com o NCM a resposta é bem mais rápida
"documento": "nfe",
"destinatario": "contribuinte",
"destino": "interestadual",
}
pacote, pendentes, err := Classificar(ctx, c, produto)
respostas := map[string]any{}
for rodada := 0; err == nil && len(pendentes) > 0 && rodada < 3; rodada++ {
for _, p := range pendentes {
respostas[p.ID] = perguntarAoUsuario(p) // true/false, uma das opcoes ou texto
}
produto["respostas"] = respostas
pacote, pendentes, err = Classificar(ctx, c, produto)
}
if err == nil {
revisar("SKU-NB15", pacote)
}
// Lote: de 1 a 10 por chamada; cada item tem status próprio
lote, err := clienteLento(c).Call(ctx, "POST", "/classificacao-fiscal/lote", map[string]any{
"produtos": []map[string]string{
{"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"},
},
})
if err != nil {
log.Fatal(err)
}
var l struct {
Resultados []struct {
Referencia string `json:"referencia"`
Status string `json:"status"`
Descricao string `json:"descricao"`
Campo string `json:"campo"`
Pacote json.RawMessage `json:"pacote"`
} `json:"resultados"`
}
json.Unmarshal(lote.Data, &l)
for _, item := range l.Resultados {
if item.Status != "005" { // 400: corrija item.Campo; 999: reenvie só este produto
log.Printf("%s: %s", item.Referencia, item.Descricao)
continue
}
revisar(item.Referencia, item.Pacote)
}

Rotinas

Uma rotina emite a mesma NFS-e sozinha em cada data da agenda (mensalidade, aluguel, condomínio). Depois de ativa, ela emite nota fiscal sem ninguém olhando: confira antes de criar. Veja Rotinas de emissão automática.

func CriarRotinaMensal(ctx context.Context, c *myse.Client) (int, error) {
// 1. Modelos e campos: o "nome" de cada campo é a chave a usar em "parametros"
if _, err := c.Call(ctx, "GET", "/rotinas/modelos", nil); err != nil {
return 0, err
}
rotina := map[string]any{
"modelo": "NFSE_RECORRENTE",
"nome": "Suporte mensal - ACME",
"periodicidade": "mensal",
"dia": 10,
"inicio": "2026-11-01",
// Exceção ao kebab-case: as chaves de parametros são os nomes do modelo (snake_case)
"parametros": map[string]any{
"id_clifor": 1262804, // id de GET /rotinas/clientes?busca=
"id_produto": 88231, // id de GET /rotinas/servicos
"vl_servico": "3.500,50",
"ds_discriminacao": "Suporte técnico de {competencia}",
},
}
// 2. Conferir sem gravar
conferida, err := c.Call(ctx, "POST", "/rotinas/validar", rotina)
if err != nil {
return 0, err
}
var v struct {
PodeAtivar bool `json:"pode-ativar"`
Pendencias []string `json:"pendencias"`
}
json.Unmarshal(conferida.Data, &v)
if !v.PodeAtivar {
return 0, fmt.Errorf("%s %v", conferida.Descricao, v.Pendencias)
}
// 3. Criar: sem "ativar", a rotina já sai ativa
criada, err := c.Call(ctx, "POST", "/rotinas", rotina)
if err != nil {
return 0, err
}
if criada.Status != "001" {
return 0, fmt.Errorf("rotina não criada: %s", criada.Descricao)
}
var r struct {
Rotina struct {
ID int `json:"id-rotina"`
} `json:"rotina"`
}
json.Unmarshal(criada.Data, &r)
return r.Rotina.ID, nil
}
func EmitirEAcompanhar(ctx context.Context, c *myse.Client, id int, competencia string) error {
base := fmt.Sprintf("/rotinas/%d", id)
// 4. A agenda não emite o mês da criação se o dia já passou: emita agora
agora, err := c.Call(ctx, "POST", base+"/emitir-agora", map[string]string{"competencia": competencia})
if err != nil {
return err
}
if agora.Status != "001" { // ex.: competência já processada
return fmt.Errorf("emitir-agora: %s", agora.Descricao)
}
// 5. Histórico: "Enviada para emissão" não é "autorizada"; o desfecho sai no recibo da NFS-e
hist, err := c.Call(ctx, "GET", base+"/execucoes", nil)
if err != nil {
return err
}
var h struct {
Execucoes []struct {
Competencia string `json:"competencia"`
Situacao string `json:"situacao"` // E, F, P ou C
Recibo *string `json:"recibo"`
} `json:"execucoes"`
}
json.Unmarshal(hist.Data, &h)
for _, e := range h.Execucoes {
if e.Recibo == nil {
continue
}
nfse, err := AguardarRecibo(ctx, c, "/nfse/nota", *e.Recibo, 0)
if err != nil {
return err
}
log.Printf("%s: status %s", e.Competencia, nfse.Status)
}
return nil
}
// 6. Parar de emitir (só rotina ativa; retome com POST /rotinas/{id}/retomar)
func PausarRotina(ctx context.Context, c *myse.Client, id int) (*myse.ApiResponse, error) {
return c.Call(ctx, "POST", fmt.Sprintf("/rotinas/%d/pausar", id), nil)
}
// Detalhe: agenda, pendências e o diagnóstico (por que emitiu ou não). 005; 500 = não encontrada
func DetalharRotina(ctx context.Context, c *myse.Client, id int) error {
resp, err := c.Call(ctx, "GET", fmt.Sprintf("/rotinas/%d", id), nil)
if err != nil {
return err
}
if resp.Status != "005" {
return fmt.Errorf("rotina %d: %s", id, resp.Descricao)
}
var d struct {
Rotina struct {
Situacao string `json:"situacao"`
ProximaEmissao *string `json:"proxima-emissao"`
Pendencias []string `json:"pendencias"`
Diagnostico string `json:"diagnostico"`
} `json:"rotina"`
}
json.Unmarshal(resp.Data, &d)
log.Printf("%s | pendências %v | %s", d.Rotina.Situacao, d.Rotina.Pendencias, d.Rotina.Diagnostico)
return nil
}
// 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).
func AlterarRotina(ctx context.Context, c *myse.Client, id int) error {
resp, err := c.Call(ctx, "PUT", fmt.Sprintf("/rotinas/%d", id), map[string]any{
"dia": 5,
"parametros": map[string]any{"vl_servico": 3800},
})
if err != nil {
return err
}
if resp.Status != "001" { // 400: data.campo e/ou data.pendencias
return fmt.Errorf("alteração recusada: %s", resp.Descricao)
}
return nil
}
// Valor extra num mês: soma à nota e ao boleto só daquela competência (rotina ativa,
// próximos meses da agenda). Os meses possíveis vêm em competencias-disponiveis.
func LancarExtra(ctx context.Context, c *myse.Client, id int, competencia string) error {
base := fmt.Sprintf("/rotinas/%d/extras", id)
lista, err := c.Call(ctx, "GET", base, nil)
if err != nil {
return err
}
var ex struct {
CompetenciasDisponiveis []string `json:"competencias-disponiveis"`
}
json.Unmarshal(lista.Data, &ex)
log.Printf("meses possíveis: %v", ex.CompetenciasDisponiveis)
resp, err := c.Call(ctx, "PUT", base+"/"+competencia, map[string]any{ // competencia: "2026-12"
"valor": 250,
"motivo": "Visita técnica extra em 02/12", // 3 a 100 caracteres; aparece na nota
})
if err != nil {
return err
}
if resp.Status != "001" { // 400: modelo sem extra (ex.: condomínio), mês fechado
return fmt.Errorf("extra recusado: %s", resp.Descricao)
}
return nil
}
// Remover o extra (não vale para mês já emitido ou em emissão)
func RemoverExtra(ctx context.Context, c *myse.Client, id int, competencia string) (*myse.ApiResponse, error) {
return c.Call(ctx, "DELETE", fmt.Sprintf("/rotinas/%d/extras/%s", id, competencia), nil)
}
// Excluir a rotina: 001 "Rotina excluída."
func ExcluirRotina(ctx context.Context, c *myse.Client, id int) (*myse.ApiResponse, error) {
return c.Call(ctx, "DELETE", fmt.Sprintf("/rotinas/%d", id), nil)
}

Certificado digital A1

Instala o .pfx da empresa e acompanha a validade, sem passar pela tela do FazNota. Responde na hora, sem recibo. Desde a 3.20.0. Veja Certificado digital A1.

Terminal window
export MYSE_PFX_SENHA="senha_do_pfx"
func InstalarCertificadoA1(ctx context.Context, c *myse.Client, caminhoPfx string) (json.RawMessage, error) {
pfx, err := os.ReadFile(caminhoPfx)
if err != nil {
return nil, err
}
// A senha vem do ambiente (ou de um cofre). NUNCA registre em log a senha, o arquivo
// ou o corpo desta requisição: com os dois, qualquer um assina em nome da empresa.
senha := os.Getenv("MYSE_PFX_SENHA")
if senha == "" {
return nil, errors.New("defina MYSE_PFX_SENHA")
}
resp, err := c.Call(ctx, "POST", "/certificado/a1", map[string]string{
"arquivo": base64.StdEncoding.EncodeToString(pfx),
"senha": senha,
})
if err != nil {
return nil, err
}
if resp.Status != "001" {
// 400: senha errada, não é ICP-Brasil, vencido, de outro CNPJ, vence antes do atual...
return nil, errors.New(resp.Descricao)
}
return resp.Data, nil // situacao, valido-ate, dias-para-vencer
}
type Certificado struct {
Tipo string `json:"tipo"` // A1 ou A3
Situacao string `json:"situacao"` // VALIDO, A_VENCER, VENCIDO, NAO_INSTALADO, INDISPONIVEL
DtValidade string `json:"dt-validade"`
DiasParaVencer int `json:"dias-para-vencer"`
Instalado bool `json:"instalado"`
}
// Monitoramento diário da validade
func ConsultarCertificado(ctx context.Context, c *myse.Client) (*Certificado, error) {
resp, err := c.Call(ctx, "GET", "/certificado", nil)
if err != nil {
return nil, err
}
var cert Certificado
if err := json.Unmarshal(resp.Data, &cert); err != nil {
return nil, err
}
if cert.Situacao == "A_VENCER" || cert.Situacao == "VENCIDO" {
avisarCliente(fmt.Sprintf("Certificado vence em %d dias (%s)", cert.DiasParaVencer, cert.DtValidade))
}
return &cert, nil
}

CIOT

Declara na ANTT a operação de transporte e devolve o código do CIOT. É para ETC com RNTRC ativo e certificado A1. Veja Emitir CIOT.

func EmitirCIOT(ctx context.Context, c *myse.Client, numeroViagem string) (json.RawMessage, error) {
// Os campos seguem o leiaute PEF da ANTT (PascalCase), não o kebab-case da v3
body := map[string]any{
"numero-origem": numeroViagem, // estável por viagem: o reenvio devolve o recibo original
"TipoOperacao": 1, // 1 carga lotação, 2 carga fracionada
"CpfCnpjContratante": "12345678000199",
"CpfCnpjDestinatario": "98765432000155",
"ValorFrete": 1500.00,
"Veiculos": []map[string]any{{"Placa": "ABC1D23", "NumeroEixos": "4"}},
"OrigemDestino": []map[string]any{{
"Origem": map[string]any{"CodigoMunicipioOrigem": 4127700},
"Destino": map[string]any{"CodigoMunicipioDestino": 4104808},
"DistanciaPercorrida": 45,
}},
"DadosCarga": map[string]any{"CodigoNaturezaCarga": 9999, "CodigoTipoCarga": 5, "PesoCarga": 1000},
"InfIndicadoresOperacionais": map[string]bool{
"IndAltoDesempenho": false, "IndRetornoVazio": false, "ComposicaoVeicular": false,
},
"InfPagamento": []map[string]any{{
"TipoPagamento": 6, "IndPagamento": 0, // Pix, à vista
"ChavePix": "[email protected]",
"IdentificadorPix": "FRETE-2026-1021",
}},
}
pedido, err := c.Call(ctx, "POST", "/ciot/emissao", body)
if err != nil {
return nil, err
}
if pedido.Status != "001" { // 400: A3, sem RNTRC, TipoOperacao inválido...
return nil, fmt.Errorf("CIOT recusado na hora: %s", pedido.Descricao)
}
var d struct {
Recibo string `json:"recibo"`
}
json.Unmarshal(pedido.Data, &d)
// Se der 999 (falha com a ANTT), reenvie com o MESMO numero-origem: não gera um segundo CIOT
resultado, err := AguardarRecibo(ctx, c, "/ciot", d.Recibo, 0)
if err != nil {
return nil, err
}
if resultado.Status != "004" { // 900: motivo em data.erro ou data.antt.mensagem
return nil, fmt.Errorf("CIOT recusado: %s", resultado.Data)
}
return resultado.Data, nil // ciot, codigo-verificador, protocolo, situacao
}
// Encerrar ao fim da viagem (pelo código do CIOT ou pelo recibo da emissão)
func EncerrarCIOT(ctx context.Context, c *myse.Client, ciot string) (*myse.ApiResponse, error) {
enc, err := c.Call(ctx, "POST", "/ciot/encerramento", map[string]string{"ciot": ciot})
if err != nil {
return nil, err
}
var d struct {
Recibo string `json:"recibo"`
}
json.Unmarshal(enc.Data, &d)
return AguardarRecibo(ctx, c, "/ciot", d.Recibo, 0)
}
// Eventos do CIOT: enviam e aguardam o recibo próprio do evento em GET /ciot/{recibo}
func eventoCIOT(ctx context.Context, c *myse.Client, path string, body map[string]any) (*myse.ApiResponse, error) {
resp, err := c.Call(ctx, "POST", path, body)
if err != nil {
return nil, err
}
if resp.Status != "001" {
return nil, fmt.Errorf("%s recusado na hora: %s", path, resp.Descricao)
}
var d struct {
Recibo string `json:"recibo"`
}
json.Unmarshal(resp.Data, &d)
return AguardarRecibo(ctx, c, "/ciot", d.Recibo, 0)
}
// 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.
func RetificarCIOT(ctx context.Context, c *myse.Client, ciot string) (*myse.ApiResponse, error) {
return eventoCIOT(ctx, c, "/ciot/retificacao", map[string]any{
"ciot": ciot,
"ValorFrete": 1650.00,
"PesoCarga": 1200,
}) // 004 = retificado; 900 = recusado
}
// Cancelar (por "ciot" ou "recibo" da emissão). motivo obrigatório, até 500 caracteres.
// CIOT REJEITADO pela ANTT só é marcado como cancelado no FazNota, sem chamar a ANTT.
func CancelarCIOT(ctx context.Context, c *myse.Client, ciot, motivo string) error {
res, err := eventoCIOT(ctx, c, "/ciot/cancelamento", map[string]any{"ciot": ciot, "motivo": motivo})
if err != nil {
return err
}
if res.Status != "010" {
return fmt.Errorf("cancelamento do CIOT recusado (status %s)", res.Status)
}
return nil
}

RENAVE

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

func EntradaRENAVE(ctx context.Context, c *myse.Client, chaveNFe string) (string, error) {
// Os campos do RENAVE são camelCase (chaveNFe, valorCompra), não kebab-case
pedido, err := c.Call(ctx, "POST", "/renave/nota-fiscal/entrada", map[string]any{
"chaveNFe": chaveNFe, // NF-e modelo 55 de entrada, emitida pela própria empresa
"cpfOperadorResponsavel": "12345678901",
"dataCompra": "2026-10-20",
"valorCompra": 45000.00,
"emailVendedor": "[email protected]",
"veiculo": map[string]any{
"placa": "ABC1D23",
"numeroCrv": "123456789012",
"renavam": "01234567890",
"codigoSegurancaCrv": "12345678901",
"tipoCrv": "DIGITAL",
"dataHoraMedicaoHodometro": "2026-10-20T10:00:00",
"quilometragemHodometro": 52000,
"documentoProprietarioAtual": "98765432100",
"tipoDocumentoProprietarioAtual": "CPF",
},
})
if err != nil {
return "", err
}
if pedido.Status != "001" { // 400: campo fora da regra, sem A1...
return "", fmt.Errorf("RENAVE recusado na hora: %s", pedido.Descricao)
}
var d struct {
Recibo string `json:"recibo"`
}
json.Unmarshal(pedido.Data, &d)
resultado, err := AguardarRecibo(ctx, c, "/renave", d.Recibo, 0)
if err != nil {
return "", err
}
// Guarde o id-renave: ele identifica o registro no cancelamento
r := lerRenave(resultado)
if resultado.Status != "004" { // 900: motivo em data.mensagem ou data.erro
return "", fmt.Errorf("RENAVE recusou (%s): %s", resultado.Status, r.motivo())
}
return r.IDRenave, nil
}
// A resposta do RENAVE traz dados pessoais (CPF, endereço do comprador): nunca registre o
// Data inteiro em log nem em erro. Decodifique só os campos de que precisa.
type resultadoRenave struct {
IDRenave string `json:"id-renave"`
IDEstoque string `json:"id-estoque"`
Mensagem string `json:"mensagem"`
Erro string `json:"erro"`
}
func (r resultadoRenave) motivo() string {
if r.Mensagem != "" {
return r.Mensagem
}
return r.Erro
}
func lerRenave(resp *myse.ApiResponse) resultadoRenave {
var r resultadoRenave
json.Unmarshal(resp.Data, &r)
return r
}
// Envia, confere o 001 e aguarda o desfecho em GET /renave/{recibo}.
// 004 registrado · 010 cancelado · 900 recusado · 999 erro técnico (reenvie o MESMO pedido)
func operacaoRenave(ctx context.Context, c *myse.Client, path string, body map[string]any) (*myse.ApiResponse, resultadoRenave, error) {
pedido, err := c.Call(ctx, "POST", path, body)
if err != nil {
return nil, resultadoRenave{}, err
}
if pedido.Status != "001" { // 400: recusado na hora
return nil, resultadoRenave{}, fmt.Errorf("%s recusado na hora: %s", path, pedido.Descricao)
}
var d struct {
Recibo string `json:"recibo"`
}
json.Unmarshal(pedido.Data, &d)
res, err := AguardarRecibo(ctx, c, "/renave", d.Recibo, 0)
if err != nil {
return nil, resultadoRenave{}, err
}
return res, lerRenave(res), nil
}
// Saída do estoque (venda), vinculada à NF-e de venda modelo 55
func SaidaRENAVE(ctx context.Context, c *myse.Client) (string, error) {
res, r, err := operacaoRenave(ctx, c, "/renave/nota-fiscal/saida", map[string]any{
"chaveNFe": "35261012345678000190550010000012351000012356",
"cpfOperadorResponsavel": "12345678901",
"dataVenda": "2026-10-25",
"valorVenda": 52000.00,
"veiculo": map[string]any{
"placa": "ABC1D23", "numeroCrv": "123456789012", "renavam": "01234567890",
},
"comprador": map[string]any{
"nome": "Maria Souza",
"email": "[email protected]",
"tipoDocumento": "CPF",
"numeroDocumento": "98765432100",
"endereco": map[string]any{
"logradouro": "Av. Paulista", "numero": "1000", "bairro": "Bela Vista",
"cep": "01310100", "municipio": "São Paulo", "uf": "SP",
},
},
})
if err != nil {
return "", err
}
if res.Status != "004" {
return "", fmt.Errorf("saída recusada (%s): %s", res.Status, r.motivo())
}
return r.IDRenave, nil
}
// 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.
func EntradaVeiculoProprio(ctx context.Context, c *myse.Client) (string, error) {
res, r, err := operacaoRenave(ctx, c, "/renave/estoque/entrada-veiculo-proprio", map[string]any{
"chaveNFe": "35261012345678000190550010000012361000012367",
"cpfOperadorResponsavel": "12345678901",
"dataEntradaEstoque": "2026-10-20",
"veiculo": map[string]any{
"placa": "DEF4G56",
"numeroCrv": "223456789012",
"renavam": "11234567890",
"codigoSegurancaCrv": "22345678901",
"tipoCrv": "DIGITAL",
"dataHoraMedicaoHodometro": "2026-10-20T09:00:00",
"quilometragemHodometro": 18000,
},
})
if err != nil {
return "", err
}
if res.Status != "004" {
return "", fmt.Errorf("entrada recusada (%s): %s", res.Status, r.motivo())
}
return r.IDRenave, nil
}
// Cancelar uma entrada (compra ou veículo próprio) ou uma saída registrada com sucesso.
// path: "/renave/estoque/cancelamento-entrada" ou "/renave/estoque/cancelamento-saida".
// Identifique por "id-renave" OU pelo "recibo" do registro; os dados do veículo vêm do registro.
func CancelarRENAVE(ctx context.Context, c *myse.Client, path, idRenave string) error {
res, r, err := operacaoRenave(ctx, c, path, map[string]any{"id-renave": idRenave})
if err != nil {
return err
}
if res.Status != "010" {
return fmt.Errorf("cancelamento recusado (%s): %s", res.Status, r.motivo())
}
return nil
}

Listar com paginação

func ListarTodosClientes(ctx context.Context, c *myse.Client) ([]json.RawMessage, error) {
var todos []json.RawMessage
page := 1
pageSize := 100
for {
path := fmt.Sprintf("/clientes?page=%d&page_size=%d", page, pageSize)
resp, err := c.Call(ctx, "GET", path, nil)
if err != nil {
return nil, err
}
if resp.Status != "005" {
break
}
var batch []json.RawMessage
json.Unmarshal(resp.Data, &batch)
if len(batch) == 0 {
break
}
todos = append(todos, batch...)
if len(batch) < pageSize {
break
}
page++
time.Sleep(200 * time.Millisecond)
}
return todos, nil
}

Tratamento de erros

func main() {
ctx := context.Background()
c := myse.New()
data, err := EmitirNFCe(ctx, c, pedido)
if err != nil {
if apiErr, ok := err.(*myse.ApiError); ok {
log.Printf("API error: status=%d request_id=%s msg=%s",
apiErr.HTTPStatus, apiErr.RequestID, apiErr.Message)
}
os.Exit(1)
}
log.Printf("NFCe emitida: %s", string(data))
}

Health check (sem autenticação)

// c.Base: o mesmo MYSE_API_BASE do cliente; sem o header Authorization
res, err := http.Get(c.Base + "/health")
if err != nil {
log.Fatal(err)
}
defer res.Body.Close()
var health map[string]string
json.NewDecoder(res.Body).Decode(&health)
// map[status:ok database:ok timestamp:...]
type Pool struct {
Active int `json:"active"`
Idle int `json:"idle"`
Waiting int `json:"waiting"`
Total int `json:"total"`
Max int `json:"max"`
}
// Profundo: SELECT 1 no banco + pool de conexões. 200 = UP; 503 = banco falhou ou pool saturado
deepRes, err := http.Get(c.Base + "/health/deep")
if err != nil {
log.Fatal(err)
}
defer deepRes.Body.Close()
var deep struct {
Status string `json:"status"`
TotalMs int `json:"total_ms"`
DB struct {
OK bool `json:"ok"`
LatencyMs int `json:"latency_ms"`
} `json:"db"`
Pool Pool `json:"pool"`
}
json.NewDecoder(deepRes.Body).Decode(&deep)
saudavel := deepRes.StatusCode == http.StatusOK && deep.Status == "UP"
// Só as métricas do pool, sem tocar no banco (sempre 200; status STARTING enquanto inicializa)
poolRes, err := http.Get(c.Base + "/health/pool")
if err != nil {
log.Fatal(err)
}
defer poolRes.Body.Close()
var p struct {
Status string `json:"status"`
Pool Pool `json:"pool"`
}
json.NewDecoder(poolRes.Body).Decode(&p)
log.Printf("%s ativas=%d ociosas=%d esperando=%d max=%d (saudável=%v)",
p.Status, p.Pool.Active, p.Pool.Idle, p.Pool.Waiting, p.Pool.Max, saudavel)

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.

// tipo: "nfe" | "nfce" | "nfse"
func AlterarNota(ctx context.Context, c *myse.Client, tipo, id string, dados any) (*myse.ApiResponse, error) {
return c.Call(ctx, "PUT", fmt.Sprintf("/%s/%s", tipo, id), dados)
}
// Uso:
AlterarNota(ctx, c, "nfe", "12345", map[string]any{
"serie": "1", "cfop": "5102", "cliente": "12345678000199",
"itens": []map[string]string{
{"produto": "SKU-001", "quantidade": "3", "valor-unitario": "89.90"},
},
})

Listagens

nfes, _ := c.Call(ctx, "GET", "/nfe?page=1&page_size=20", nil)
nfces, _ := c.Call(ctx, "GET", "/nfce?page=1&page_size=50", nil)
nfses, _ := c.Call(ctx, "GET", "/nfse?dataInicial=2026-05-01&page=1&page_size=20", nil)
fornecedor, _ := c.Call(ctx, "GET", "/nffornecedor?page=1&page_size=20", nil)
// Forma legada (path-based)
nfesLegado, _ := c.Call(ctx, "GET", "/nfe/paginacao/1/20", nil)

Clientes (CRUD completo)

type PessoaFisica struct {
Nome, Cpf, Rg, Email, Telefone string
Endereco map[string]string
}
func CadastrarPF(ctx context.Context, c *myse.Client, pf PessoaFisica) (*myse.ApiResponse, error) {
return c.Call(ctx, "POST", "/clientes", map[string]any{
"tipo": "F",
"nome": pf.Nome,
"cpf": pf.Cpf,
"rg": pf.Rg,
"consumidor-final": "1",
"contato": map[string]string{"email": pf.Email, "telefone": pf.Telefone},
"endereco": pf.Endereco,
})
}
type PessoaJuridica struct {
RazaoSocial, NomeFantasia, Cnpj, InscricaoMunicipal string
Contribuinte, InscricaoEstadual, Email, Telefone string
Endereco map[string]string
}
func CadastrarPJ(ctx context.Context, c *myse.Client, pj PessoaJuridica) (*myse.ApiResponse, error) {
contribuinte := pj.Contribuinte
if contribuinte == "" {
contribuinte = "9"
}
ie := pj.InscricaoEstadual
if ie == "" {
ie = "ISENTO"
}
return c.Call(ctx, "POST", "/clientes", map[string]any{
"tipo": "J",
"razao-social": pj.RazaoSocial,
"nome-fantasia": pj.NomeFantasia,
"cnpj": pj.Cnpj,
"inscricao-municipal": pj.InscricaoMunicipal,
"tipo-inscricao-estadual": contribuinte,
"inscricao-estadual": ie,
"consumidor-final": "0",
"contato": map[string]string{"email": pj.Email, "telefone": pj.Telefone},
"endereco": pj.Endereco,
})
}
// Consultar por CPF/CNPJ
cliente, _ := c.Call(ctx, "GET", "/clientes/12345678000199", nil)
// Buscar por nome
encontrados, _ := c.Call(ctx, "GET", "/clientes/busca/exemplo", nil)
top, _ := c.Call(ctx, "GET", "/clientes/busca/top_clientes", nil)
// Atualizar
c.Call(ctx, "PUT", "/clientes/12345678000199", map[string]string{
"tipo": "J",
"razao-social": "Empresa Exemplo (Novo Nome) Ltda",
})
// Excluir
c.Call(ctx, "DELETE", "/clientes/12345678000199", nil)

Produtos (CRUD completo)

type Produto struct {
Sku, Nome, Medida, Categoria, Ncm, Origem, Cfop string
Valor float64
ConfiguracoesFiscais []any
}
func CadastrarProduto(ctx context.Context, c *myse.Client, p Produto) (*myse.ApiResponse, error) {
medida := p.Medida
if medida == "" {
medida = "UN"
}
origem := p.Origem
if origem == "" {
origem = "0"
}
cfop := p.Cfop
if cfop == "" {
cfop = "5102"
}
return c.Call(ctx, "POST", "/produtos", map[string]any{
"referencia": p.Sku,
"nome": p.Nome,
"valor": fmt.Sprintf("%.2f", p.Valor),
"medida": medida,
"categoria": p.Categoria,
"ncm": p.Ncm,
"origem": origem,
"cfop-preferencial": cfop,
"tipo-produto": "P",
"configuracoes-fiscais": p.ConfiguracoesFiscais,
})
}
type Servico struct {
Sku, Nome, CodigoServico string
Valor float64
}
func CadastrarServico(ctx context.Context, c *myse.Client, s Servico) (*myse.ApiResponse, error) {
return c.Call(ctx, "POST", "/produtos", map[string]any{
"referencia": s.Sku,
"nome": s.Nome,
"valor": fmt.Sprintf("%.2f", s.Valor),
"medida": "H",
"tipo-produto": "S",
"codigo-servico": s.CodigoServico,
})
}
// Consultar
produto, _ := c.Call(ctx, "GET", "/produtos/SKU-001", nil)
porNome, _ := c.Call(ctx, "GET", "/produtos/nome/Camiseta", nil)
// Listar paginado com busca (use _todos para não filtrar)
todos, _ := c.Call(ctx, "GET", "/produtos/paginacao/1/20/_todos", nil)
filtrados, _ := c.Call(ctx, "GET", "/produtos/paginacao/1/20/Camiseta", nil)
// Atualizar
c.Call(ctx, "PUT", "/produtos/SKU-001", map[string]string{
"referencia": "SKU-001",
"nome": "Camiseta Polo M (Novo)",
"valor": "99.90",
})
// Excluir
c.Call(ctx, "DELETE", "/produtos/SKU-001", nil)