Ejemplos prácticos

Aprende a integrar la API de Verifactu con ejemplos reales, código funcional y guías paso a paso. Desde casos básicos hasta implementaciones avanzadas.

Casos de uso populares

🛒

E-commerce

Integra facturación automática en tu tienda online con Verifactu y Ticketbai.

💼

ERP/CRM

Conecta tu sistema de gestión empresarial con las obligaciones fiscales.

📱

Apps móviles

Añade capacidades de facturación a tu aplicación móvil de forma sencilla.

🔄

Automatización

Automatiza procesos de facturación con webhooks y procesamiento en lote.

Ejemplos de código

📄

Crear una factura básica

Aprende a crear tu primera factura con la API de Verifactu

Básico Python 5 min
  1. 1

    Instalar el SDK

    Instala la librería oficial de Python para Verifactu-API

  2. 2

    Configurar autenticación

    Configura tu API key para autenticar las peticiones

  3. 3

    Crear la factura

    Envía los datos de la factura y recibe la confirmación

# Instalar el SDK de Python
pip install verifactu-api

# O con poetry
poetry add verifactu-api
from verifactu_api import VerifactuClient

# Configurar cliente
client = VerifactuClient(api_key="tu_api_key_aqui")

# Datos de la factura
factura_data = {
    "nif_emisor": "12345678A",
    "nif_receptor": "87654321B", 
    "numero_factura": "FAC-2025-001",
    "fecha_expedicion": "2025-01-15",
    "lineas": [
        {
            "descripcion": "Servicio de consultoría",
            "cantidad": 1,
            "precio_unitario": 1000.00,
            "tipo_iva": 21
        }
    ]
}

# Crear factura
try:
    factura = client.facturas.create(factura_data)
    print(f"Factura creada: {factura.id}")
    print(f"Estado: {factura.estado}")
except Exception as e:
    print(f"Error: {e}")
{
  "id": "fac_456789",
  "numero_factura": "FAC-2025-001",
  "estado": "procesando",
  "verifactu_estado": "pendiente",
  "ticketbai_estado": "pendiente",
  "qr_code": null,
  "created_at": "2025-01-15T10:30:00Z",
  "updated_at": "2025-01-15T10:30:00Z"
}
Resultado esperado:

La factura se crea exitosamente y queda en estado "procesando" mientras se envía a Verifactu y Ticketbai. Recibirás webhooks cuando cambie el estado.

🛒

Integración con e-commerce

Automatiza la facturación en tu tienda online con Node.js

Intermedio Node.js 15 min
  1. 1

    Configurar webhook endpoint

    Crea un endpoint para recibir notificaciones de pedidos

  2. 2

    Procesar pedido

    Convierte los datos del pedido en formato de factura

  3. 3

    Enviar a Verifactu

    Crea la factura automáticamente y maneja errores

// package.json dependencies
{
  "dependencies": {
    "@verifactu-api/sdk": "^1.8.2",
    "express": "^4.18.0",
    "body-parser": "^1.20.0"
  }
}

// Instalar dependencias
npm install @verifactu-api/sdk express body-parser
const express = require('express');
const { VerifactuClient } = require('@verifactu-api/sdk');

const app = express();
const client = new VerifactuClient({
  apiKey: process.env.VERIFACTU_API_KEY
});

app.use(express.json());

// Webhook para nuevos pedidos
app.post('/webhook/order-completed', async (req, res) => {
  try {
    const order = req.body;
    
    // Validar webhook signature (recomendado)
    if (!validateWebhookSignature(req)) {
      return res.status(401).send('Unauthorized');
    }
    
    // Procesar pedido
    await processOrder(order);
    
    res.status(200).send('OK');
  } catch (error) {
    console.error('Error processing order:', error);
    res.status(500).send('Error');
  }
});

function validateWebhookSignature(req) {
  // Implementar validación de firma
  return true; // Simplificado para el ejemplo
}
async function processOrder(order) {
  // Convertir pedido a formato de factura
  const facturaData = {
    nif_emisor: "12345678A", // Tu NIF
    nif_receptor: order.customer.nif,
    numero_factura: `ORD-${order.id}`,
    fecha_expedicion: new Date().toISOString().split('T')[0],
    lineas: order.items.map(item => ({
      descripcion: item.name,
      cantidad: item.quantity,
      precio_unitario: item.price,
      tipo_iva: item.vat_rate || 21
    }))
  };
  
  try {
    // Crear factura en Verifactu
    const factura = await client.facturas.create(facturaData);
    
    // Guardar ID de factura en tu base de datos
    await updateOrderWithInvoice(order.id, factura.id);
    
    console.log(`Factura ${factura.id} creada para pedido ${order.id}`);
    
    // Opcional: Enviar email al cliente
    await sendInvoiceEmail(order.customer.email, factura);
    
  } catch (error) {
    // Manejar errores y reintentar si es necesario
    console.error(`Error creating invoice for order ${order.id}:`, error);
    await scheduleRetry(order.id);
  }
}

async function updateOrderWithInvoice(orderId, invoiceId) {
  // Actualizar tu base de datos
  // db.orders.update({id: orderId}, {invoice_id: invoiceId});
}

async function sendInvoiceEmail(email, factura) {
  // Enviar email con la factura
  console.log(`Sending invoice ${factura.id} to ${email}`);
}
Resultado esperado:

Cada vez que se complete un pedido en tu tienda, se creará automáticamente una factura en Verifactu. El cliente recibirá un email con la factura y todos los datos quedarán registrados para cumplir con las obligaciones fiscales.

⚡

Procesamiento en lote

Procesa múltiples facturas de forma eficiente con PHP

Avanzado PHP 30 min
  1. 1

    Preparar datos en lote

    Organiza múltiples facturas para procesamiento eficiente

  2. 2

    Implementar rate limiting

    Respeta los límites de la API para evitar errores

  3. 3

    Manejar errores y reintentos

    Implementa lógica robusta para casos de error

pushHandler(new StreamHandler('logs/batch.log', Logger::INFO));

// Configurar cliente API
$client = new Client([
    'api_key' => $_ENV['VERIFACTU_API_KEY'],
    'timeout' => 30,
    'retry_attempts' => 3
]);
client = $client;
        $this->logger = $logger;
    }
    
    public function processBatch($invoices) {
        $batches = array_chunk($invoices, $this->batchSize);
        $results = [];
        
        foreach ($batches as $batchIndex => $batch) {
            $this->logger->info("Processing batch " . ($batchIndex + 1) . "/" . count($batches));
            
            $batchResults = $this->processSingleBatch($batch);
            $results = array_merge($results, $batchResults);
            
            // Rate limiting - esperar entre lotes
            if ($batchIndex < count($batches) - 1) {
                sleep($this->delayBetweenBatches);
            }
        }
        
        return $results;
    }
    
    private function processSingleBatch($batch) {
        $results = [];
        
        foreach ($batch as $invoiceData) {
            try {
                $result = $this->processInvoice($invoiceData);
                $results[] = [
                    'success' => true,
                    'invoice_id' => $result['id'],
                    'original_data' => $invoiceData
                ];
                
                $this->logger->info("Invoice created successfully", [
                    'invoice_id' => $result['id'],
                    'numero_factura' => $invoiceData['numero_factura']
                ]);
                
            } catch (Exception $e) {
                $results[] = [
                    'success' => false,
                    'error' => $e->getMessage(),
                    'original_data' => $invoiceData
                ];
                
                $this->logger->error("Failed to create invoice", [
                    'error' => $e->getMessage(),
                    'numero_factura' => $invoiceData['numero_factura']
                ]);
            }
            
            // Pequeña pausa entre facturas individuales
            usleep(100000); // 0.1 segundos
        }
        
        return $results;
    }
    
    private function processInvoice($invoiceData) {
        return $this->client->facturas()->create($invoiceData);
    }
}
processBatch($invoices);

// Analizar resultados
$successful = array_filter($results, fn($r) => $r['success']);
$failed = array_filter($results, fn($r) => !$r['success']);

echo "Procesamiento completado:\n";
echo "Exitosas: " . count($successful) . "\n";
echo "Fallidas: " . count($failed) . "\n";

// Guardar resultados para seguimiento
saveProcessingResults($results);

// Programar reintentos para las fallidas
if (!empty($failed)) {
    scheduleRetries($failed);
}

function loadPendingInvoices() {
    // Cargar desde tu base de datos
    return [
        [
            'nif_emisor' => '12345678A',
            'nif_receptor' => '87654321B',
            'numero_factura' => 'BATCH-001',
            'fecha_expedicion' => date('Y-m-d'),
            'lineas' => [
                [
                    'descripcion' => 'Producto 1',
                    'cantidad' => 1,
                    'precio_unitario' => 100.00,
                    'tipo_iva' => 21
                ]
            ]
        ],
        // ... más facturas
    ];
}

function saveProcessingResults($results) {
    // Guardar en base de datos para auditoría
    file_put_contents(
        'results/batch_' . date('Y-m-d_H-i-s') . '.json',
        json_encode($results, JSON_PRETTY_PRINT)
    );
}

function scheduleRetries($failed) {
    // Programar reintentos para facturas fallidas
    foreach ($failed as $failedInvoice) {
        // Añadir a cola de reintentos
        echo "Scheduling retry for: " . $failedInvoice['original_data']['numero_factura'] . "\n";
    }
}
Resultado esperado:

El sistema procesará cientos o miles de facturas de forma eficiente, respetando los límites de la API, manejando errores graciosamente y proporcionando logs detallados para auditoría y seguimiento.

Recursos adicionales

📚 Documentación completa

Guías detalladas, referencia de API y mejores prácticas para cada endpoint y funcionalidad.

🧪 Playground interactivo

Prueba todos los endpoints en tiempo real sin escribir código. Perfecto para explorar la API.

💬 Soporte técnico

Únete a nuestro Slack de desarrolladores o contacta directamente con nuestro equipo técnico.

¿Necesitas un ejemplo específico?

Si no encuentras el ejemplo que necesitas, contáctanos. Nuestro equipo puede crear ejemplos personalizados para tu caso de uso específico.

Solicitar ejemplo Probar en playground