Facturación y cobros automatizados con n8n: automatiza facturas, recordatorios y seguimiento de cobros

Problema resuelto

Como consultor o solopreneur, probablemente enfrentas:

• Crear facturas manualmente cada mes
• Enviar recordatorios de pago individualmente
• Seguir clientes con pagos pendientes
• Conciliar pagos con facturas
• Gestionar planes de pago y daciones

Esta guía te enseñará a automatizar todo el ciclo de facturación con n8n + Stripe + Clientify.

Stack tecnológico necesario

• n8n Cloud: Orquestación del flujo de facturación
• Stripe: Procesamiento de pagos recurrentes
• Clientify: Gestión de clientes y comunicaciones
• Google Sheets/Notion: Registro de facturas
• PDF Generator: Creación automática de facturas

Diagrama del flujo completo

Fecha de facturación → n8n detecta → Crea factura → Envía email → Stripe procesa → WhatsApp confirma → Recordatorios automáticos

Paso 1: Configurar trigger mensual en n8n

// Schedule trigger para día 1 de cada mes a las 9:00
const monthlyBilling = {
  schedule: {
    cron: '0 9 1 * *', // Día 1 de cada mes a las 9:00
    timezone: 'Europe/Madrid'
  }
};

Paso 2: Obtener clientes con facturas pendientes

// Función para obtener clientes activos
const getActiveClients = async () => {
  const clients = await clientifyAPI.getContacts({
    tags: ['cliente-activo'],
    customFields: ['plan-precio', 'frecuencia-facturacion', 'metodo-pago']
  });
  
  return clients.filter(client => {
    return client.customFields['frecuencia-facturacion'] === 'mensual' &&
           client.customFields['metodo-pago'] === 'stripe';
  });
};

const activeClients = await getActiveClients();

Paso 3: Generar facturas automáticamente

// Crear factura para cada cliente
const createInvoice = async (client) => {
  const invoiceData = {
    customer: client.stripeCustomerId,
    currency: 'eur',
    description: `Servicios de consultoría - ${new Date().toLocaleDateString('es-ES', { month: 'long', year: 'numeric' })}`,
    line_items: [{
      quantity: 1,
      price_data: {
        currency: 'eur',
        unit_amount: client.customFields['plan-precio'] * 100, // Convertir a centavos
        product_data: {
          name: 'Servicios de consultoría mensual',
          description: client.serviceDescription
        }
      }
    }],
    collection_method: 'send_invoice',
    days_until_due: 30,
    metadata: {
      client_id: client.id,
      client_name: client.name,
      billing_period: `${new Date().getFullYear()}-${String(new Date().getMonth() + 1).padStart(2, '0')}`
    }
  };
  
  return await stripeAPI.invoices.create(invoiceData);
};

Paso 4: Enviar notificaciones por múltiples canales

Email formal con factura

const sendInvoiceEmail = async (invoice, client) => {
  const emailTemplate = {
    to: client.email,
    subject: `Factura ${invoice.number} - ${client.companyName}`,
    template: 'invoice-sent',
    variables: {
      clientName: client.name,
      invoiceNumber: invoice.number,
      invoiceAmount: formatCurrency(invoice.total / 100),
      dueDate: new Date(invoice.due_date).toLocaleDateString('es-ES'),
      invoiceLink: invoice.hosted_invoice_url,
      paymentLink: invoice.payment_url
    }
  };
  
  await emailService.send(emailTemplate);
};

WhatsApp con recordatorio amigable

const sendWhatsAppNotification = async (invoice, client) => {
  const whatsappMessage = {
    to: client.phone,
    template: 'invoice_notification',
    language: 'es',
    components: [{
      type: 'body',
      parameters: [
        { type: 'text', text: client.name.split(' ')[0] },
        { type: 'text', text: invoice.number },
        { type: 'text', text: formatCurrency(invoice.total / 100) },
        { type: 'text', text: new Date(invoice.due_date).toLocaleDateString('es-ES') }
      ]
    }]
  };
  
  await clientifyAPI.sendWhatsApp(whatsappMessage);
};

Paso 5: Sistema de recordatorios escalonados

// Configurar recordatorios automáticos
const setupReminders = async (invoice, client) => {
  const reminders = [
    { days: 7, channel: 'email', template: 'reminder-7-days' },
    { days: 3, channel: 'whatsapp', template: 'reminder-3-days' },
    { days: 1, channel: 'both', template: 'reminder-1-day' },
    { days: 0, channel: 'both', template: 'due-today' },
    { days: -3, channel: 'email', template: 'overdue-3-days' },
    { days: -7, channel: 'email', template: 'overdue-1-week' },
    { days: -14, channel: 'email', template: 'overdue-2-weeks' }
  ];
  
  reminders.forEach(reminder => {
    const reminderDate = new Date(invoice.due_date);
    reminderDate.setDate(reminderDate.getDate() + reminder.days);
    
    // Programar recordatorio
    n8nAPI.scheduleWorkflow({
      workflowId: 'payment-reminder',
      triggerDate: reminderDate,
      data: {
        invoiceId: invoice.id,
        clientId: client.id,
        channel: reminder.channel,
        template: reminder.template
      }
    });
  });
};

Paso 6: Gestión de pagos y conciliación

// Webhook para eventos de Stripe
const handleStripeWebhook = async (event) => {
  switch (event.type) {
    case 'invoice.payment_succeeded':
      await handlePaymentSucceeded(event.data.object);
      break;
    case 'invoice.payment_failed':
      await handlePaymentFailed(event.data.object);
      break;
    case 'invoice.finalized':
      await handleInvoiceFinalized(event.data.object);
      break;
  }
};

const handlePaymentSucceeded = async (invoice) => {
  // Actualizar estado en Clientify
  await clientifyAPI.updateContact(invoice.metadata.client_id, {
    tags: ['factura-pagada'],
    customFields: {
      'ultimo-pago': new Date().toISOString(),
      'estado-facturacion': 'al-dia'
    }
  });
  
  // Enviar confirmación
  await sendPaymentConfirmation(invoice);
  
  // Registrar en Google Sheets
  await sheetsAPI.appendRow({
    spreadsheetId: 'FINANCIAL_TRACKING',
    range: 'Pagos!A:G',
    values: [
      invoice.id,
      invoice.metadata.client_name,
      invoice.total / 100,
      new Date().toISOString(),
      'stripe',
      'completed',
      invoice.metadata.billing_period
    ]
  });
};

Paso 7: Dashboard financiero en tiempo real

// Métricas financieras clave
const getFinancialMetrics = async () => {
  const currentMonth = new Date().toISOString().slice(0, 7);
  
  const invoices = await stripeAPI.invoices.list({
    created: { gte: `${currentMonth}-01` },
    limit: 100
  });
  
  const metrics = {
    totalInvoiced: invoices.data.reduce((sum, inv) => sum + inv.total, 0) / 100,
    totalPaid: invoices.data
      .filter(inv => inv.status === 'paid')
      .reduce((sum, inv) => sum + inv.total, 0) / 100,
    totalPending: invoices.data
      .filter(inv => inv.status === 'open')
      .reduce((sum, inv) => sum + inv.total, 0) / 100,
    totalOverdue: invoices.data
      .filter(inv => inv.status === 'uncollectible')
      .reduce((sum, inv) => sum + inv.total, 0) / 100,
    paymentRate: (invoices.data.filter(inv => inv.status === 'paid').length / invoices.data.length) * 100,
    averagePaymentTime: calculateAveragePaymentTime(invoices.data)
  };
  
  return metrics;
};

Paso 8: Manejo de casos especiales

Planes de pago personalizados

const createPaymentPlan = async (client, totalAmount, installments) => {
  const installmentAmount = Math.round(totalAmount / installments);
  
  for (let i = 0; i < installments; i++) {
    const dueDate = new Date();
    dueDate.setMonth(dueDate.getMonth() + i);
    
    await stripeAPI.invoices.create({
      customer: client.stripeCustomerId,
      currency: 'eur',
      description: `Plan de pago - Cuota ${i + 1}/${installments}`,
      line_items: [{
        quantity: 1,
        price_data: {
          currency: 'eur',
          unit_amount: installmentAmount * 100,
          product_data: {
            name: `Plan de pago - Cuota ${i + 1}/${installments}`
          }
        }
      }],
      due_date: Math.floor(dueDate.getTime() / 1000),
      metadata: {
        payment_plan_id: `plan-${client.id}-${Date.now()}`,
        installment_number: i + 1,
        total_installments: installments
      }
    });
  }
};

Daciones y cancelaciones

const handleWriteOff = async (invoice, reason) => {
  // Marcar factura como no cobrable
  await stripeAPI.invoices.update(invoice.id, {
    status: 'uncollectible',
    metadata: {
      write_off_reason: reason,
      write_off_date: new Date().toISOString()
    }
  });
  
  // Actualizar cliente
  await clientifyAPI.updateContact(invoice.metadata.client_id, {
    tags: ['factura-cancelada'],
    customFields: {
      'estado-facturacion': 'con-morosidad',
      'ultima-cancelacion': new Date().toISOString()
    }
  });
  
  // Notificar internamente
  await slackAPI.postMessage({
    channel: '#finanzas',
    text: `⚠️ Factura ${invoice.number} cancelada por ${reason}. Monto: ${formatCurrency(invoice.total / 100)}`
  });
};

Métricas para monitorizar

KPIs de facturación

• Tasa de pago: >85% en 30 días
• Días promedio de pago: <15 días
• Tasa de morosidad: <10%
• Coste de gestión: <5 EUR por factura

Métricas de eficiencia

• Tiempo de procesamiento: <5 minutos por factura
• Errores manuales: 0
• Horas ahorradas: 15+ horas/mes
• ROI del sistema: >400%

Resumen de beneficios

✅ Menos morosidad con recordatorios automáticos escalonados
✅ Ahorro 15+ horas mensuales en tareas administrativas
✅ Cash flow predecible con facturación consistente
✅ Mejor experiencia cliente con comunicación proactiva
✅ Datos en tiempo real para toma de decisiones

Próximos pasos

1. Implementa flujo básico con clientes existentes
2. Mide resultados durante 2 meses
3. Optimiza timing y canales según respuesta
4. Expande a otros procesos (presupuestos, gastos, etc.)

Con este sistema, transformarás la facturación de una carga manual a un proceso automatizado que mejora tu cash flow y libera tiempo para actividades de alto valor.