Go
HTTP directo · no hay librería de Facta para Go
La API es HTTP y JSON, así que Go la llama con net/http, sin nada más. Lo que sigue es un programa completo —no un fragmento— que emite una factura y trata cada final por su nombre.
Requisitos
- Go 1.22 o superior, con
net/httpde la biblioteca estándar. - Una llave de API con el alcance
issue, y su llave de firma. - Un destino de almacenamiento conectado en la app — sin él la emisión se detiene con
422 no_storage_destinationantes de reservar correlativo.
URL base
https://hcnvknpsbadplnfcflxx.supabase.co/functions/v1/api-v1Variables de entorno
# Las tres cadenas se muestran UNA sola vez, al acuñar la llave.
FACTA_API_KEY=facta_test_k7f3a9c21.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
FACTA_SIGN_KEY=factask_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Esta tercera NO se le pasa a Facta ni al cliente: abre sus credenciales
# de almacenamiento en SU servidor.
FACTA_UNLOCK_KEY=factauk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxEl ejemplo completo
// Emitir un DTE contra la API de Facta con net/http.
//
// Objetivo: Go 1.22 o superior. No hay librería de Facta para Go — esto es
// HTTP directo, no un cliente oficial.
//
// FACTA_API_BASE_URL=https://hcnvknpsbadplnfcflxx.supabase.co/functions/v1/api-v1 \
// FACTA_API_KEY=facta_test_... FACTA_SIGN_KEY=factask_... \
// PEDIDO_ID=pedido-00417 go run emitir.go
//
// Lo que cubre: estado antes de emitir, una Idempotency-Key que su sistema
// posee (no una al azar por intento), 200 / 202 / 422 distintos, timeout de
// 60 s, lectura de RateLimit-Remaining y descarga del JSON firmado byte a
// byte. Nunca usa FACTA_UNLOCK_KEY — esa cadena abre SU almacenamiento, no
// esta API.
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"time"
)
var cliente = &http.Client{Timeout: 60 * time.Second}
func peticion(metodo, base, ruta string, firma bool, cuerpo map[string]any, pedidoID string) (int, http.Header, []byte, error) {
var lector io.Reader
if cuerpo != nil {
bytesCuerpo, err := json.Marshal(cuerpo)
if err != nil {
return 0, nil, nil, err
}
lector = bytes.NewReader(bytesCuerpo)
}
solicitud, err := http.NewRequest(metodo, base+ruta, lector)
if err != nil {
return 0, nil, nil, err
}
solicitud.Header.Set("X-Facta-Key", os.Getenv("FACTA_API_KEY"))
if firma {
solicitud.Header.Set("X-Facta-Sign-Key", os.Getenv("FACTA_SIGN_KEY"))
}
if cuerpo != nil {
solicitud.Header.Set("Content-Type", "application/json")
// El identificador de ESTA venta — en un sistema real viene de su
// propia base de datos y se persiste antes de la primera llamada,
// para que un reintento use el mismo valor en vez de uno nuevo.
solicitud.Header.Set("Idempotency-Key", pedidoID)
}
respuesta, err := cliente.Do(solicitud)
if err != nil {
return 0, nil, nil, err
}
defer respuesta.Body.Close()
cuerpoBytes, err := io.ReadAll(respuesta.Body)
if err != nil {
return 0, nil, nil, err
}
return respuesta.StatusCode, respuesta.Header, cuerpoBytes, nil
}
func main() {
base := trimSlash(os.Getenv("FACTA_API_BASE_URL"))
pedidoID := os.Getenv("PEDIDO_ID")
if pedidoID == "" {
pedidoID = "pedido-00417"
}
// 1) El estado primero: confirma que la llave sirve y cuánto cupo queda.
// No pide X-Facta-Sign-Key y no gasta el cupo de emitir.
estado, _, cuerpo, err := peticion("GET", base, "/v1/status", false, nil, "")
fatalIf(err)
if estado != 200 {
fmt.Fprintln(os.Stderr, "no se pudo leer el estado de la llave:", string(cuerpo))
os.Exit(1)
}
var info map[string]any
fatalIf(json.Unmarshal(cuerpo, &info))
limites := info["limites"].(map[string]any)["hora"].(map[string]any)
fmt.Printf("ambiente: %v · cupo por hora restante: %v\n", info["ambiente"], limites["remaining"])
// 2) Emitir. Una factura (01) a consumidor final: el IVA va INCLUIDO en
// precioUni, como exige el esquema oficial de este tipo de documento.
venta := map[string]any{
"tipoDte": "01",
"items": []map[string]any{
{"descripcion": "Café", "cantidad": 2, "precioUni": 1.5},
},
}
estado, cabeceras, cuerpo, err := peticion("POST", base, "/v1/dte", true, venta, pedidoID)
fatalIf(err)
fmt.Println("cupo restante:", cabeceras.Get("RateLimit-Remaining"))
var datos map[string]any
fatalIf(json.Unmarshal(cuerpo, &datos))
switch estado {
case 200:
fmt.Println("sellado:", datos["numeroControl"], datos["selloRecibido"])
case 202:
// Firmado, sin respuesta del Ministerio todavía. El documento EXISTE
// y se le debe a Hacienda: NO se reintenta esta llamada.
fmt.Println("en contingencia:", datos["numeroControl"], "—", datos["detalle"])
case 422:
error, _ := datos["error"].(map[string]any)
if error["code"] == "mh_rejected" {
detalle, _ := error["details"].(map[string]any)
fmt.Fprintln(os.Stderr, "rechazado:", error["message"])
fmt.Fprintln(os.Stderr, "número ya gastado:", detalle["numeroControl"])
} else {
fmt.Fprintln(os.Stderr, "no se pudo emitir:", error["code"], error["message"])
}
os.Exit(1)
default:
fmt.Fprintln(os.Stderr, "error inesperado:", estado, string(cuerpo))
os.Exit(1)
}
// 3) Descargar los bytes EXACTOS del JSON firmado — nunca se vuelven a
// serializar, porque eso no reproduciría los bytes que Hacienda validó.
codigo := datos["codigoGeneracion"].(string)
estado, _, archivo, err := peticion("GET", base, "/v1/dte/"+codigo+"/file?kind=json", false, nil, "")
fatalIf(err)
if estado == 200 {
nombre := codigo + ".json"
fatalIf(os.WriteFile(nombre, archivo, 0o600))
fmt.Println("archivado:", nombre)
}
}
func trimSlash(s string) string {
for len(s) > 0 && s[len(s)-1] == '/' {
s = s[:len(s)-1]
}
return s
}
func fatalIf(err error) {
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
Lo que este ejemplo no hace
Los demás lenguajes
El mismo documento, en los otros seis. Cambia la sintaxis; no cambian las cabeceras, ni los códigos, ni las reglas.
curl
# -D - vuelca las cabeceras de la respuesta, con RateLimit-Remaining (y, si aplica, Retry-After).
curl --fail-with-body -X POST "$FACTA_API_BASE_URL/v1/dte" \
-H "X-Facta-Key: $FACTA_API_KEY" \
-H "X-Facta-Sign-Key: $FACTA_SIGN_KEY" \
-H "Idempotency-Key: $PEDIDO_ID" \
-H "Content-Type: application/json" \
-D - \
--max-time 60 \
-d '{
"tipoDte": "03",
"receptor": {
"customerId": "374114b6-e957-4c7a-8911-dd6381b1e0ea"
},
"items": [
{
"descripcion": "Integración de la API de facturación electrónica",
"cantidad": 1,
"precioUni": 25
}
]
}'
JavaScript
// JavaScript puro, sin ninguna librería de Facta. Node 22 o 24; fetch es global.
const base = process.env.FACTA_API_BASE_URL;
const headers = {
"X-Facta-Key": process.env.FACTA_API_KEY,
"X-Facta-Sign-Key": process.env.FACTA_SIGN_KEY,
// Un identificador que USTED elige y REUTILIZA en cada reintento de
// esta misma operación — su número de pedido, su ticket de caja.
"Idempotency-Key": pedidoId,
"Content-Type": "application/json",
};
const controlador = new AbortController();
const plazo = setTimeout(() => controlador.abort(), 60_000);
const respuesta = await fetch(base + "/v1/dte", {
method: "POST",
headers,
body: JSON.stringify({
"tipoDte": "03",
"receptor": {
"customerId": "374114b6-e957-4c7a-8911-dd6381b1e0ea"
},
"items": [
{
"descripcion": "Integración de la API de facturación electrónica",
"cantidad": 1,
"precioUni": 25
}
]
}),
signal: controlador.signal,
}).finally(() => clearTimeout(plazo));
console.log("cupo restante:", respuesta.headers.get("RateLimit-Remaining"));
const cuerpo = await respuesta.json();
if (respuesta.status === 200) {
// Resultado correcto.
console.log(cuerpo);
}
else if (respuesta.status === 202) {
// 202: firmado, sin respuesta del Ministerio todavía. NO lo reintente.
console.log("en contingencia:", cuerpo.numeroControl);
}
else if (cuerpo.error?.code === "mh_rejected") {
console.error("rechazado:", cuerpo.error.message, "· número gastado:", cuerpo.error.details.numeroControl);
}
else {
throw new Error(cuerpo.error?.code ?? String(respuesta.status));
}
Python
import json
import os
import urllib.error
import urllib.request
base = os.environ["FACTA_API_BASE_URL"]
cabeceras = {
"X-Facta-Key": os.environ["FACTA_API_KEY"],
"X-Facta-Sign-Key": os.environ["FACTA_SIGN_KEY"],
"Idempotency-Key": pedido_id, # el mismo en cada reintento de esta operación
"Content-Type": "application/json",
}
peticion = urllib.request.Request(
base + "/v1/dte",
data=json.dumps({
"tipoDte": "03",
"receptor": {
"customerId": "374114b6-e957-4c7a-8911-dd6381b1e0ea"
},
"items": [
{
"descripcion": "Integración de la API de facturación electrónica",
"cantidad": 1,
"precioUni": 25
}
]
}).encode("utf-8"),
method="POST",
headers=cabeceras,
)
try:
# El Ministerio puede tardar unos cuarenta segundos en contestar.
with urllib.request.urlopen(peticion, timeout=60) as respuesta:
print("cupo restante:", respuesta.headers.get("RateLimit-Remaining"))
cuerpo = json.load(respuesta)
if respuesta.status == 200:
print(cuerpo)
elif respuesta.status == 202:
# Firmado, sin respuesta del Ministerio todavía. NO lo reintente.
print("en contingencia:", cuerpo["numeroControl"])
except urllib.error.HTTPError as fallo:
error = json.load(fallo).get("error", {})
if error.get("code") == "mh_rejected":
detalle = error.get("details", {})
print("rechazado:", error.get("message"), "· número gastado:", detalle.get("numeroControl"))
else:
raise
PHP
<?php
// PHP 8 con la extensión cURL. No hay librería de Facta para PHP.
$base = getenv("FACTA_API_BASE_URL");
$cabeceras = [
"X-Facta-Key: " . getenv("FACTA_API_KEY"),
"X-Facta-Sign-Key: " . getenv("FACTA_SIGN_KEY"),
"Idempotency-Key: " . $pedidoId, // el mismo en cada reintento de esta operación
"Content-Type: application/json",
];
$conexion = curl_init($base . "/v1/dte");
$cuerpo = json_encode([
"tipoDte" => "03",
"receptor" => [
"customerId" => "374114b6-e957-4c7a-8911-dd6381b1e0ea",
],
"items" => [
[
"descripcion" => "Integración de la API de facturación electrónica",
"cantidad" => 1,
"precioUni" => 25,
],
],
], JSON_UNESCAPED_UNICODE);
curl_setopt_array($conexion, [
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HEADER => true,
CURLOPT_TIMEOUT => 60,
CURLOPT_HTTPHEADER => $cabeceras,
CURLOPT_POSTFIELDS => $cuerpo,
]);
$crudo = curl_exec($conexion);
$estado = curl_getinfo($conexion, CURLINFO_RESPONSE_CODE);
$tamCabeceras = curl_getinfo($conexion, CURLINFO_HEADER_SIZE);
curl_close($conexion);
$cabecerasRespuesta = substr($crudo, 0, $tamCabeceras);
echo "cupo restante: " . (preg_match("/RateLimit-Remaining: (\d+)/i", $cabecerasRespuesta, $m) ? $m[1] : "?") . "\n";
$datos = json_decode(substr($crudo, $tamCabeceras), true);
if ($estado === 200) {
echo json_encode($datos) . "\n";
}
elseif ($estado === 202) {
// Firmado, sin respuesta del Ministerio todavía. NO lo reintente.
echo "en contingencia: {$datos['numeroControl']}\n";
}
elseif (($datos['error']['code'] ?? null) === 'mh_rejected') {
echo "rechazado: {$datos['error']['message']}\n";
echo "número gastado: {$datos['error']['details']['numeroControl']}\n";
} else {
throw new RuntimeException($datos['error']['code'] ?? "HTTP $estado");
}
C#
// .NET 8 con HttpClient. No hay librería de Facta para C#.
using System.Net.Http.Json;
using System.Text.Json;
var base_ = Environment.GetEnvironmentVariable("FACTA_API_BASE_URL");
using var cliente = new HttpClient { Timeout = TimeSpan.FromSeconds(60) };
var peticion = new HttpRequestMessage(HttpMethod.Post, base_ + "/v1/dte");
peticion.Content = JsonContent.Create(new { tipoDte = "03", receptor = new { customerId = "374114b6-e957-4c7a-8911-dd6381b1e0ea" }, items = new[] { new { descripcion = "Integración de la API de facturación electrónica", cantidad = 1, precioUni = 25 } } });
peticion.Headers.Add("X-Facta-Key", Environment.GetEnvironmentVariable("FACTA_API_KEY"));
peticion.Headers.Add("X-Facta-Sign-Key", Environment.GetEnvironmentVariable("FACTA_SIGN_KEY"));
peticion.Headers.Add("Idempotency-Key", pedidoId); // el mismo en cada reintento de esta operación
var respuesta = await cliente.SendAsync(peticion);
Console.WriteLine({{OTROS}}
quot;cupo restante: {respuesta.Headers.GetValues("RateLimit-Remaining").FirstOrDefault()}");
using var datos = JsonDocument.Parse(await respuesta.Content.ReadAsStringAsync());
var raiz = datos.RootElement;
if ((int)respuesta.StatusCode == 200)
Console.WriteLine(raiz);
else if ((int)respuesta.StatusCode == 202)
// Firmado, sin respuesta del Ministerio todavía. NO lo reintente.
Console.WriteLine({{OTROS}}
quot;en contingencia: {raiz.GetProperty("numeroControl")}");
else if (raiz.TryGetProperty("error", out var error) && error.GetProperty("code").GetString() == "mh_rejected")
Console.WriteLine({{OTROS}}
quot;rechazado: {error.GetProperty("message")} · gastó {error.GetProperty("details").GetProperty("numeroControl")}");
else
throw new InvalidOperationException(respuesta.StatusCode.ToString());
Java
// JDK 17 o superior, con java.net.http. No hay librería de Facta para Java.
import java.net.URI;
import java.net.http.*;
import java.time.Duration;
public final class Emitir {
public static void main(String[] args) throws Exception {
var base = System.getenv("FACTA_API_BASE_URL");
var constructor = HttpRequest.newBuilder(URI.create(base + "/v1/dte"))
.header("X-Facta-Key", System.getenv("FACTA_API_KEY"))
.header("X-Facta-Sign-Key", System.getenv("FACTA_SIGN_KEY"))
// El mismo pedidoId en cada reintento de esta operación.
.header("Idempotency-Key", pedidoId)
.timeout(Duration.ofSeconds(60))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString("""
{
"tipoDte": "03",
"receptor": {
"customerId": "374114b6-e957-4c7a-8911-dd6381b1e0ea"
},
"items": [
{
"descripcion": "Integración de la API de facturación electrónica",
"cantidad": 1,
"precioUni": 25
}
]
}
"""));
var peticion = constructor.build();
var respuesta = HttpClient.newHttpClient().send(peticion, HttpResponse.BodyHandlers.ofString());
System.out.println("cupo restante: " + respuesta.headers().firstValue("RateLimit-Remaining").orElse("?"));
// Estados: 200 correcto · 202 correcto (el 202 queda firmado, en contingencia — no se reintenta) · 422 con "mh_rejected" si Hacienda lo negó.
System.out.println(respuesta.statusCode());
System.out.println(respuesta.body());
}
}