SDKs oficiales

pip install emitoo  # próximamente en PyPI

from emitoo import EmitooClient

client = EmitooClient(api_key="fpk_...")  # o export EMITOO_API_KEY=fpk_...

# 1. Emitir una factura. Con idempotency_key, reintentar el mismo POST
#    devuelve la MISMA factura (no la duplica).
factura = client.facturas.crear(
    {
        "tipo_identificacion": "04",  # 04 = RUC, 05 = cédula
        "identificacion": "0991234567001",
        "razon_social": "ACME S.A.",
        "email": "facturacion@acme.example",
        "detalles": [
            {"codigo_principal": "LIC-1", "descripcion": "Licencia mensual",
             "cantidad": 1, "precio_unitario": 75.0, "tarifa_iva": 15},
        ],
    },
    idempotency_key="orden-8912",
)
print(factura["id"], factura["estado"])  # 177 "PENDIENTE"

# 2. El envío al SRI es asíncrono: espera a un estado final
#    (lanza TimeoutError si se agota el tiempo).
factura = client.facturas.esperar_autorizacion(factura["id"], timeout=60.0)
print(factura["estado"])  # "AUTORIZADO"

# 3. Descargar el RIDE (PDF) — devuelve bytes.
pdf = client.facturas.ride(factura["id"])

client.close()

from emitoo import EmitooError, ValidationError, RateLimitError

try:
    client.facturas.crear(payload, idempotency_key="orden-8912")
except ValidationError as exc:
    print(exc.status_code, exc.errors)   # 422, detail de FastAPI/Pydantic
except RateLimitError as exc:
    print("reintenta en", exc.retry_after, "segundos")
except EmitooError as exc:
    print("error de Emitoo:", exc.status_code, exc.message)

npm install emitoo  # próximamente en npm

import { Emitoo } from "emitoo";

const client = new Emitoo({ apiKey: "fpk_..." }); // o export EMITOO_API_KEY=fpk_...

// 1. Emitir una factura. Con idempotencyKey, reintentar el mismo POST
//    devuelve la MISMA factura (no la duplica).
const factura = await client.facturas.crear(
  {
    tipo_identificacion: "04", // 04 = RUC, 05 = cédula
    identificacion: "0991234567001",
    razon_social: "ACME S.A.",
    email: "facturacion@acme.example",
    detalles: [
      { codigo_principal: "LIC-1", descripcion: "Licencia mensual",
        cantidad: 1, precio_unitario: 75.0, tarifa_iva: 15 },
    ],
  },
  { idempotencyKey: "orden-8912" },
);
console.log(factura.id, factura.estado); // 177 "PENDIENTE"

// 2. El envío al SRI es asíncrono: espera a un estado final
//    (lanza TimeoutError si se agota el tiempo).
const autorizada = await client.facturas.esperarAutorizacion(factura.id, {
  timeoutMs: 60_000,
});
console.log(autorizada.estado); // "AUTORIZADO"

// 3. Descargar el RIDE (PDF) — devuelve Uint8Array.
const pdf = await client.facturas.ride(factura.id);

import { EmitooError, ValidationError, RateLimitError } from "emitoo";

try {
  await client.facturas.crear(payload, { idempotencyKey: "orden-8912" });
} catch (exc) {
  if (exc instanceof ValidationError) {
    console.log(exc.status, exc.errors); // 422, detail de FastAPI/Pydantic
  } else if (exc instanceof RateLimitError) {
    console.log("reintenta en", exc.retryAfter, "segundos");
  } else if (exc instanceof EmitooError) {
    console.log("error de Emitoo:", exc.status, exc.message);
  } else {
    throw exc;
  }
}

go get github.com/Killkanacode/emitoo-go  # próximamente

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/Killkanacode/emitoo-go"
)

func main() {
	client, err := emitoo.New("fpk_...") // o export EMITOO_API_KEY=fpk_...
	if err != nil {
		log.Fatal(err)
	}
	ctx := context.Background()

	// 1. Emitir una factura. Con WithIdempotencyKey, reintentar el mismo
	//    POST devuelve la MISMA factura (no la duplica).
	factura, err := client.Facturas.Crear(ctx, emitoo.M{
		"tipo_identificacion": "04", // 04 = RUC, 05 = cédula
		"identificacion":      "0991234567001",
		"razon_social":        "ACME S.A.",
		"email":               "facturacion@acme.example",
		"detalles": []emitoo.M{
			{"codigo_principal": "LIC-1", "descripcion": "Licencia mensual",
				"cantidad": 1, "precio_unitario": 75.0, "tarifa_iva": 15},
		},
	}, emitoo.WithIdempotencyKey("orden-8912"))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(factura["id"], factura["estado"]) // 177 PENDIENTE

	// 2. El envío al SRI es asíncrono: espera a un estado final
	//    (retorna un error que envuelve emitoo.ErrTimeout si se agota).
	id := int(factura["id"].(float64))
	factura, err = client.Facturas.EsperarAutorizacion(ctx, id, 60*time.Second, 2*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(factura["estado"]) // AUTORIZADO

	// 3. Descargar el RIDE (PDF) — devuelve []byte.
	pdf, err := client.Facturas.Ride(ctx, id)
	if err != nil {
		log.Fatal(err)
	}
	_ = pdf
}

factura, err := client.Facturas.Crear(ctx, payload)
if err != nil {
	var apiErr *emitoo.APIError
	switch {
	case emitoo.IsValidation(err): // 422
		errors.As(err, &apiErr)
		fmt.Println(apiErr.StatusCode, apiErr.Errors) // detail de FastAPI/Pydantic
	case emitoo.IsRateLimit(err): // 429
		errors.As(err, &apiErr)
		fmt.Println("reintenta en", *apiErr.RetryAfter, "segundos")
	default:
		fmt.Println("error de Emitoo:", err)
	}
}

# Tipos TS a partir de la OpenAPI
npx openapi-typescript https://api.emitoo.io/api/v1/public/openapi.json \
  -o src/emitoo.d.ts

# O un cliente completo
npx @hey-api/openapi-ts \
  -i https://api.emitoo.io/api/v1/public/openapi.json \
  -o src/emitoo

# Cliente Python tipado (pydantic + httpx)
pip install openapi-python-client
openapi-python-client generate \
  --url https://api.emitoo.io/api/v1/public/openapi.json