Exemplos em Go
Setup
Requer Go 1.21+. Sem dependências externas (usa stdlib).
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 realizadafunc 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, }) 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 Authorizationfunc 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 respostasproduto := 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ópriolote, 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 encontradafunc 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.
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 validadefunc 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 "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, "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 55func 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", "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 Authorizationres, err := http.Get(c.Base + "/health")if err != nil { log.Fatal(err)}defer res.Body.Close()var health map[string]stringjson.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 saturadodeepRes, 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/CNPJcliente, _ := c.Call(ctx, "GET", "/clientes/12345678000199", nil)
// Buscar por nomeencontrados, _ := c.Call(ctx, "GET", "/clientes/busca/exemplo", nil)top, _ := c.Call(ctx, "GET", "/clientes/busca/top_clientes", nil)
// Atualizarc.Call(ctx, "PUT", "/clientes/12345678000199", map[string]string{ "tipo": "J", "razao-social": "Empresa Exemplo (Novo Nome) Ltda",})
// Excluirc.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, })}
// Consultarproduto, _ := 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)
// Atualizarc.Call(ctx, "PUT", "/produtos/SKU-001", map[string]string{ "referencia": "SKU-001", "nome": "Camiseta Polo M (Novo)", "valor": "99.90",})
// Excluirc.Call(ctx, "DELETE", "/produtos/SKU-001", nil)