factadesarrolladores API 0.1.0-esqueleto

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/http de 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_destination antes de reservar correlativo.
URL basehttps://hcnvknpsbadplnfcflxx.supabase.co/functions/v1/api-v1

Variables de entorno

sh
# 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_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

El ejemplo completo

goarchivo real · sdks/go/examples/emitir.go
// 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

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
// 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

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
// 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#

csharp
// .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

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());
  }
}

Escriba para buscar Por ejemplo: idempotencia, contingencia, 422, emitir.

↑ ↓ moverse Enter abrir Esc cerrar