How to Automate Billing with Stripe in 2026

Introduction

Automating billing is essential for any SaaS or online service in 2026. Manually handling subscriptions, generating PDFs, and sending reminders leads to costly errors and hinders scalability. With Stripe Billing, you centralize recurring payments, while webhooks trigger automated actions like creating PDF invoices and sending emails.

This intermediate tutorial guides you step-by-step to build a complete system in Node.js/TypeScript: receiving Stripe webhooks (e.g., invoice.paid), generating custom PDFs with pdfkit, and sending via nodemailer. Imagine: a customer pays, and in 5 seconds, they receive their invoice by email.

Why it matters: Reduce churn by 20-30% with a smooth experience, save 10 hours/week, and stay GDPR-compliant with traceable logs. Ready to turn your billing into an autonomous machine? (128 words)

Prerequisites

Node.js 20+ installed
Stripe account (test mode enabled, API keys retrieved)
Basic knowledge of TypeScript and Express
SMTP server (Gmail App Password or SendGrid)
Tools: npm/yarn, ngrok for local webhook testing

Project Initialization

terminal

mkdir billing-automation && cd billing-automation
npm init -y
npm install express stripe pdfkit nodemailer @types/node @types/express dotenv stripe-node-webhook
npm install -D typescript ts-node @types/pdfkit @types/nodemailer
npx tsc --init --target es2022 --module commonjs --outDir ./dist --rootDir ./src --strict

This script sets up a Node.js project, installs essential dependencies (Stripe SDK, pdfkit for PDFs, nodemailer for emails), and configures TypeScript. Types prevent runtime errors. Run it for a ready setup in 1 minute; stripe-node-webhook simplifies signature validation.

Environment Variable Setup

Create a .env file at the root:

plaintext
STRIPE_SECRET_KEY=sk_test_your_secret_key
STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=your.email@gmail.com
SMTP_PASS=your_app_password

Analogy: Like a safe, these vars protect your API keys. Never hardcode them! Add .env to .gitignore. In Stripe Dashboard > Developers > Webhooks, create an endpoint https://your-domain.com/webhook and select invoice.paid, invoice.payment_failed.

Main Server Structure

src/server.ts

import express from 'express';
import dotenv from 'dotenv';
import { Stripe } from 'stripe-node-webhook';

dotenv.config();

const app = express();
app.use(express.raw({ type: 'application/json' }));
app.use(express.json());

const stripe = new Stripe({
  webhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
  apiKey: process.env.STRIPE_SECRET_KEY!
});

const PORT = 3000;

app.listen(PORT, () => {
  console.log(`Billing server on port ${PORT}`);
});

export { app, stripe };

This base Express server handles body parsers for webhooks (raw JSON required by Stripe) and initializes the webhook validator. It listens on port 3000 for local testing. Pitfall: Forgetting express.raw() breaks signature validation. Launch with npx ts-node src/server.ts.

Webhook Endpoint with Validation

src/webhook.ts

import { app, stripe } from './server';
import { generateInvoicePDF, sendInvoiceEmail } from './invoice';

app.post('/webhook', async (req, res) => {
  try {
    const event = await stripe.parseWebhookRequest(req);
    if (event.type === 'invoice.paid') {
      const invoice = event.data.object as any;
      await generateInvoicePDF(invoice);
      await sendInvoiceEmail(invoice.customer_email, invoice.hosted_invoice_url);
    } else if (event.type === 'invoice.payment_failed') {
      console.log('Payment failed:', event.data.object);
    }
    res.status(200).json({ received: true });
  } catch (err) {
    console.error('Webhook error:', err);
    res.status(400).send(`Webhook Error: ${err}`);
  }
});

This endpoint automatically validates Stripe signatures via stripe-node-webhook, processes invoice.paid by generating PDF/email. For payment_failed, log for follow-ups. Security: Always respond with 200, or Stripe will retry indefinitely. Integrate after server.ts.

Custom PDF Invoice Generation

PDFs must look professional: logo, line items, calculated VAT. Use pdfkit for SVG-like rendering. Store them at /invoices/{id}.pdf or S3. Tip: Test with ngrok (ngrok http 3000) to expose locally to Stripe.

PDF Generation Function

src/invoice.ts

import PDFDocument from 'pdfkit';
import fs from 'fs';

export async function generateInvoicePDF(invoice: any): Promise<string> {
  return new Promise((resolve, reject) => {
    const doc = new PDFDocument();
    const filename = `./invoices/${invoice.id}.pdf`;
    doc.pipe(fs.createWriteStream(filename));

    doc.fontSize(25).text('Facture', 50, 50);
    doc.fontSize(12).text(`ID: ${invoice.id}`, 50, 100);
    doc.text(`Montant: ${invoice.amount_paid / 100}€`, 50, 120);
    doc.text(`Client: ${invoice.customer_email}`, 50, 140);
    doc.text(`Date: ${new Date(invoice.created * 1000).toLocaleDateString('fr-FR')}`, 50, 160);

    doc.end();
    doc.on('end', () => resolve(filename));
    doc.on('error', reject);
  });
}

This function creates a basic but extensible PDF (add logo with doc.image()). Uses Promise for async handling. Pitfall: Synchronous fs blocks; use async. Create invoices/ folder first. Scalable to AWS S3 with multer-s3.

Email Sending Function with Attachment

src/invoice.ts

import nodemailer from 'nodemailer';

export async function sendInvoiceEmail(email: string, invoiceUrl: string): Promise<void> {
  const transporter = nodemailer.createTransporter({
    host: process.env.SMTP_HOST,
    port: Number(process.env.SMTP_PORT),
    secure: false,
    auth: {
      user: process.env.SMTP_USER,
      pass: process.env.SMTP_PASS
    }
  });

  // Attachez PDF généré
  await transporter.sendMail({
    from: process.env.SMTP_USER,
    to: email,
    subject: 'Votre facture est disponible',
    html: `<p>Facture attachée. <a href="${invoiceUrl}">Voir en ligne</a></p>`,
    attachments: [{ path: `./invoices/${invoiceUrl.split('/').pop()!}.pdf` }]
  });
}

Nodemailer sends HTML email + PDF attachment. Auth for Gmail: Enable 2FA + App Password. Pitfall: TLS port (587) vs SSL (465). Log transporter.sendMail for debugging. For production, switch to SendGrid/Resend for >99% deliverability.

Testing and Production Deployment

Local: npm run dev, ngrok, test with Stripe CLI (stripe listen --forward-to localhost:3000/webhook).
Prod: Vercel/Render, set env vars, HTTPS required.
Check Stripe Dashboard logs for retries.

Example flow: Subscription → Payment → Webhook → PDF → Email (2s total).

Best Practices

Idempotency: Check invoice.id in DB to avoid duplicates (use Prisma/PlanetScale).
Security: Always validate signatures; rate-limit /webhook with express-rate-limit.
Scalability: Use queues (BullMQ/Redis) for async PDF/email; monitor with Sentry.
GDPR: Store PDFs <90 days, anonymize logs.
Testing: Stripe test clocks to simulate time (e.g., end of period).

Common Errors to Avoid

Invalid signature: Forgot express.raw() or wrong secret → infinite 400 errors.
Emails in spam: No DKIM/SPF → Use transactional email provider.
Corrupted PDF: Async fs error → Await all Promises.
No retries: Ignore payment_failed → Implement auto-dunning via Stripe.

Next Steps

Stripe Billing docs: stripe.com/billing
Advanced: Integrate EU taxes with Stripe Tax, multi-currency.
Resources: Advanced webhooks tutorial

Check out our Learni courses on Node.js and Stripe to master scalable full-stack development.