DEV Community: Antonio Garrido

How I built a SaaS that sends AI-written Stripe reports every Monday — and what I learned

Antonio Garrido — Thu, 26 Mar 2026 09:37:17 +0000

I've been building Autoreport for the past few months alongside my day job. The idea was simple: every Monday morning, get a PDF in your inbox with your Stripe numbers from the previous week — no dashboards, no manual work.

Here's how I built it, the stack I chose, and the lessons I learned along the way.

The problem

I kept opening Stripe every Monday to check the previous week. Revenue, payments, new customers. It wasn't hard — just friction. And because it required effort, I kept skipping it or doing it badly.

I wanted the numbers to come to me, not the other way around.

The stack

The entire backend runs on AWS, deployed with Terraform:

Lambda (Python) — one function per stage of the pipeline: data extraction, AI narrative generation, PDF building, email delivery
EventBridge — triggers the pipeline every Monday morning
S3 — stores raw Stripe data and generated reports
DynamoDB — tenant registry
SES — email delivery
Secrets Manager — stores each customer's Stripe API key
Bedrock (Claude Haiku) — generates the AI narrative from the weekly metrics
API Gateway + Lambda — handles Paddle webhooks for subscription management

The landing page is a static site on Netlify. Payments go through Paddle as Merchant of Record.

How it works

Customer subscribes via Paddle checkout
Automated email via SES asks for their Stripe read-only API key
Customer replies with the key, I register them manually via a script (intentionally simple for beta)
Every Monday, EventBridge triggers the pipeline per tenant
Lambda pulls Stripe data, sends it to Bedrock, builds a PDF, delivers it via SES

What surprised me

Bedrock prompt engineering took longer than expected. The first version of the AI narrative was alarmist — "critical concern", "immediate attention" — for perfectly normal week-over-week fluctuations. I had to be very explicit in the prompt about tone, context, and when strong language is actually warranted.

The Merchant of Record route (Paddle) was the right call for avoiding tax and VAT headaches as a solo founder in Spain. The approval process took a few days but was worth it.

What's next

Right now it's in beta. If you run a SaaS on Stripe and want your week summarized every Monday without lifting a finger, give it a try at autoreport.dev.

Happy to answer any questions about the architecture or the build process.

How to validate Spanish NIF, NIE, CIF and IBAN in Python

Antonio Garrido — Thu, 12 Mar 2026 11:43:50 +0000

How to Validate Spanish NIF, NIE, CIF and IBAN in Python

If you've ever built a form or backend system for the Spanish market, you've likely had to validate fiscal identifiers like NIF, NIE, CIF or IBAN. Each one has its own algorithm, edge cases, and validation rules — and implementing them correctly from scratch is surprisingly tricky.

In this article, I'll show you how to validate all four identifier types with a single API call using Python, without having to implement or maintain the validation algorithms yourself.

The Problem with DIY Validation

Spanish fiscal identifiers are more complex than they look:

NIF: 8 digits + 1 letter, validated with a modulo-23 algorithm
NIE: Starts with X, Y or Z, then follows the NIF algorithm with substitution
CIF: Letter + 7 digits + control character (can be a letter or digit depending on the entity type)
IBAN: ES + 2 check digits + 20-digit BBAN, validated with MOD-97

Most implementations online have subtle bugs — incorrect CIF letter validation, missing NIE edge cases, or IBAN check digit errors. Getting it wrong means accepting invalid identifiers or rejecting valid ones.

A Better Approach: Use an API

Valix is a REST API that validates Spanish fiscal identifiers using the official algorithms. It handles NIF, NIE, CIF and IBAN, detects the type automatically, and returns a structured JSON response.

You can try it for free — no registration, no API key required for the trial endpoint.

Getting Started

No libraries to install beyond requests:

pip install requests

Trial: Validate Without Registration

The trial endpoint allows up to 5 identifiers per call and 50 validations per day per IP — no API key needed.

import requests

def validate_identifiers_trial(identifiers: list[str]) -> dict:
    """
    Validate Spanish fiscal identifiers using the Valix trial endpoint.
    No API key required. Max 5 identifiers per call, 50/day per IP.
    """
    url = "https://api.getvalix.io/v1/validate/trial"

    payload = {
        "items": [
            {"value": identifier, "type": "AUTO"}
            for identifier in identifiers
        ]
    }

    response = requests.post(url, json=payload)
    response.raise_for_status()
    return response.json()


# Example usage
identifiers = [
    "12345678Z",    # NIF
    "X1234567L",    # NIE
    "A12345674",    # CIF
    "ES9121000418450200051332"  # IBAN
]

result = validate_identifiers_trial(identifiers[:5])  # Max 5 for trial

for item in result["results"]:
    status = "✓ valid" if item["valid"] else "✗ invalid"
    print(f"{item['value']} → {item['detected_type']} {status}")

Output:

12345678Z → NIF ✓ valid
X1234567L → NIE ✓ valid
A12345674 → CIF ✓ valid
ES9121000418450200051332 → IBAN ✓ valid

Production: Batch Validation with API Key

For production use, the batch endpoint supports up to 100 identifiers per call. Get your API key at getvalix.io.

import requests
import os

def validate_batch(identifiers: list[str], api_key: str) -> dict:
    """
    Validate up to 100 Spanish fiscal identifiers in a single API call.
    Requires a valid API key from getvalix.io.
    """
    url = "https://api.getvalix.io/v1/validate/batch"

    headers = {
        "x-api-key": api_key,
        "Content-Type": "application/json"
    }

    payload = {
        "items": [
            {"value": identifier, "type": "AUTO"}
            for identifier in identifiers
        ]
    }

    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    return response.json()


# Load API key from environment variable (never hardcode it)
api_key = os.environ.get("VALIX_API_KEY")

identifiers = [
    "12345678Z",
    "X1234567L", 
    "A12345674",
    "ES9121000418450200051332",
    "99999999R",   # Invalid NIF
]

result = validate_batch(identifiers, api_key)

print(f"Total: {result['total']}")
print(f"Valid: {result['valid_count']}")
print(f"Invalid: {result['invalid_count']}")
print()

for item in result["results"]:
    if item["valid"]:
        print(f"✓ {item['value']} → {item['detected_type']}")
    else:
        print(f"✗ {item['value']} → {', '.join(item['errors'])}")

Output:

Total: 5
Valid: 4
Invalid: 1

✓ 12345678Z → NIF
✓ X1234567L → NIE
✓ A12345674 → CIF
✓ ES9121000418450200051332 → IBAN
✗ 99999999R → Formato inválido

Understanding the Response

Each result includes:

{
  "index": 0,
  "value": "12345678Z",
  "requested_type": "AUTO",
  "detected_type": "NIF",
  "valid": true,
  "formatted": "12345678Z",
  "errors": []
}

detected_type: the actual identifier type (NIF, NIE, CIF, IBAN)
valid: boolean result
formatted: normalized version of the identifier
errors: list of validation error messages if invalid

For CIF identifiers, the response also includes entity_type — the type of Spanish business entity (e.g. "Sociedad Anónima").

Handling Errors Gracefully

import requests
from requests.exceptions import HTTPError

def validate_with_error_handling(identifiers: list[str], api_key: str) -> dict | None:
    try:
        result = validate_batch(identifiers, api_key)
        return result
    except HTTPError as e:
        if e.response.status_code == 401:
            print("Invalid or missing API key")
        elif e.response.status_code == 429:
            print("Monthly validation limit exceeded")
        elif e.response.status_code == 400:
            error_data = e.response.json()
            print(f"Bad request: {error_data.get('error')}")
        else:
            print(f"API error: {e}")
        return None

Type-Specific Validation

If you already know the type of identifier you're validating, you can pass it explicitly instead of using AUTO:

payload = {
    "items": [
        {"value": "12345678Z", "type": "NIF"},
        {"value": "X1234567L", "type": "NIE"},
        {"value": "A12345674", "type": "CIF"},
        {"value": "ES9121000418450200051332", "type": "IBAN"}
    ]
}

This is useful when your data source already provides the identifier type, or when you want to enforce a specific type validation.

Pricing

Trial: Free, 50 validations/day, no registration
Starter: €19/month — 10,000 validations/month
Growth: €49/month — 100,000 validations/month
Pro: €149/month — 1,000,000 validations/month

Summary

Validating Spanish fiscal identifiers correctly requires implementing multiple complex algorithms with edge cases that are easy to get wrong. Using Valix gives you:

Accurate validation based on official algorithms
Automatic type detection
Batch processing up to 100 identifiers per call
A free trial to test before committing

Try it at getvalix.io — the trial endpoint requires no registration.

Cómo validar NIF, NIE, CIF e IBAN en Python

Antonio Garrido — Thu, 12 Mar 2026 11:42:53 +0000

Cómo validar NIF, NIE, CIF e IBAN en Python

Si has desarrollado alguna vez un formulario o backend para el mercado español, probablemente hayas tenido que validar identificadores fiscales como el NIF, NIE, CIF o IBAN. Cada uno tiene su propio algoritmo, casos especiales y reglas de validación — e implementarlos correctamente desde cero es más complicado de lo que parece.

En este artículo te muestro cómo validar los cuatro tipos con una sola llamada API usando Python, sin tener que implementar ni mantener los algoritmos de validación.

El problema de implementar la validación tú mismo

Los identificadores fiscales españoles son más complejos de lo que aparentan:

NIF: 8 dígitos + 1 letra, validado con un algoritmo módulo-23
NIE: Empieza por X, Y o Z, luego sigue el algoritmo del NIF con sustitución
CIF: Letra + 7 dígitos + carácter de control (puede ser letra o dígito según el tipo de entidad)
IBAN: ES + 2 dígitos de control + BBAN de 20 dígitos, validado con MOD-97

La mayoría de implementaciones que encontrarás online tienen bugs sutiles — validación incorrecta de la letra del CIF, casos especiales del NIE que no se contemplan, o errores en el dígito de control del IBAN. Equivocarse significa aceptar identificadores inválidos o rechazar identificadores válidos.

Una alternativa más sencilla: usar una API

Valix es una API REST que valida identificadores fiscales españoles usando los algoritmos oficiales. Gestiona NIF, NIE, CIF e IBAN, detecta el tipo automáticamente y devuelve una respuesta JSON estructurada.

Puedes probarla gratis — sin registro ni API key para el endpoint de prueba.

Primeros pasos

Solo necesitas requests:

pip install requests

Trial: Valida sin registro

El endpoint trial permite hasta 5 identificadores por llamada y 50 validaciones diarias por IP — sin API key.

import requests

def validar_identificadores_trial(identificadores: list[str]) -> dict:
    """
    Valida identificadores fiscales españoles con el endpoint trial de Valix.
    Sin API key. Máximo 5 identificadores por llamada, 50/día por IP.
    """
    url = "https://api.getvalix.io/v1/validate/trial"

    payload = {
        "items": [
            {"value": identificador, "type": "AUTO"}
            for identificador in identificadores
        ]
    }

    response = requests.post(url, json=payload)
    response.raise_for_status()
    return response.json()


# Ejemplo de uso
identificadores = [
    "12345678Z",               # NIF
    "X1234567L",               # NIE
    "A12345674",               # CIF
    "ES9121000418450200051332"  # IBAN
]

resultado = validar_identificadores_trial(identificadores[:5])

for item in resultado["results"]:
    estado = "✓ válido" if item["valid"] else "✗ inválido"
    print(f"{item['value']} → {item['detected_type']} {estado}")

Salida:

12345678Z → NIF ✓ válido
X1234567L → NIE ✓ válido
A12345674 → CIF ✓ válido
ES9121000418450200051332 → IBAN ✓ válido

Producción: Validación batch con API key

Para uso en producción, el endpoint batch soporta hasta 100 identificadores por llamada. Obtén tu API key en getvalix.io.

import requests
import os

def validar_batch(identificadores: list[str], api_key: str) -> dict:
    """
    Valida hasta 100 identificadores fiscales españoles en una sola llamada.
    Requiere API key de getvalix.io.
    """
    url = "https://api.getvalix.io/v1/validate/batch"

    headers = {
        "x-api-key": api_key,
        "Content-Type": "application/json"
    }

    payload = {
        "items": [
            {"value": identificador, "type": "AUTO"}
            for identificador in identificadores
        ]
    }

    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    return response.json()


# Carga la API key desde variable de entorno (nunca la hardcodees)
api_key = os.environ.get("VALIX_API_KEY")

identificadores = [
    "12345678Z",
    "X1234567L",
    "A12345674",
    "ES9121000418450200051332",
    "99999999R",   # NIF inválido
]

resultado = validar_batch(identificadores, api_key)

print(f"Total: {resultado['total']}")
print(f"Válidos: {resultado['valid_count']}")
print(f"Inválidos: {resultado['invalid_count']}")
print()

for item in resultado["results"]:
    if item["valid"]:
        print(f"✓ {item['value']} → {item['detected_type']}")
    else:
        print(f"✗ {item['value']} → {', '.join(item['errors'])}")

Salida:

Total: 5
Válidos: 4
Inválidos: 1

✓ 12345678Z → NIF
✓ X1234567L → NIE
✓ A12345674 → CIF
✓ ES9121000418450200051332 → IBAN
✗ 99999999R → Formato inválido

Estructura de la respuesta

Cada resultado incluye:

{
  "index": 0,
  "value": "12345678Z",
  "requested_type": "AUTO",
  "detected_type": "NIF",
  "valid": true,
  "formatted": "12345678Z",
  "errors": []
}

detected_type: el tipo de identificador detectado (NIF, NIE, CIF, IBAN)
valid: resultado booleano
formatted: versión normalizada del identificador
errors: lista de mensajes de error si es inválido

Para CIF, la respuesta incluye además entity_type con el tipo de entidad mercantil (por ejemplo "Sociedad Anónima").

Gestión de errores

import requests
from requests.exceptions import HTTPError

def validar_con_manejo_errores(identificadores: list[str], api_key: str) -> dict | None:
    try:
        return validar_batch(identificadores, api_key)
    except HTTPError as e:
        if e.response.status_code == 401:
            print("API key inválida o ausente")
        elif e.response.status_code == 429:
            print("Límite mensual de validaciones alcanzado")
        elif e.response.status_code == 400:
            error_data = e.response.json()
            print(f"Petición incorrecta: {error_data.get('error')}")
        else:
            print(f"Error de API: {e}")
        return None

Validación por tipo específico

Si ya conoces el tipo de identificador, puedes pasarlo explícitamente en lugar de usar AUTO:

payload = {
    "items": [
        {"value": "12345678Z", "type": "NIF"},
        {"value": "X1234567L", "type": "NIE"},
        {"value": "A12345674", "type": "CIF"},
        {"value": "ES9121000418450200051332", "type": "IBAN"}
    ]
}

Útil cuando tu fuente de datos ya proporciona el tipo, o cuando quieres forzar la validación de un tipo concreto.

Precios

Trial: Gratis, 50 validaciones/día, sin registro
Starter: €19/mes — 10.000 validaciones/mes
Growth: €49/mes — 100.000 validaciones/mes
Pro: €149/mes — 1.000.000 validaciones/mes

Resumen

Validar correctamente los identificadores fiscales españoles requiere implementar múltiples algoritmos complejos con casos especiales difíciles de contemplar. Usar Valix te da:

Validación precisa basada en algoritmos oficiales
Detección automática del tipo de identificador
Procesamiento batch de hasta 100 identificadores por llamada
Trial gratuito sin registro

Pruébalo en getvalix.io — el endpoint trial no requiere registro.