> ## Content Index
> Fetch the complete content index at: https://blog.devutilites.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Planes de Cloudflare Workers: Free frente a Paid, qué incluye cada uno y cuánto cuesta de verdad
- URL: https://blog.devutilites.com/cloudflare-workers-free-vs-paid/
- Published: 2026-10-03T03:13:55.000Z
- Updated: 2026-10-03T03:13:55.000Z
- Description: Qué incluye Workers Free y qué cambia con Workers Paid por 5 dólares al mes: límites de CPU y peticiones, qué pasa al superarlos, precios de Workers, KV, D1, R2, Durable Objects, Queues y Logs, ejemplos oficiales y una calculadora en TypeScript.
- Author: Luis Collantes
- Tags: Cloudflare, DevOps

Una de las razones por las que tanta gente empieza con Cloudflare Workers es que **el plan gratuito da para mucho**: 100.000 peticiones al día, KV, D1, Durable Objects, colas y ficheros estáticos ilimitados, sin tarjeta. Y cuando se queda corto, el siguiente escalón no es un salto a cientos de euros: **Workers Paid cuesta 5 dólares al mes** e incluye una cantidad de uso que muchos proyectos no llegan a superar.

Pero la letra pequeña importa. El límite de CPU del plan gratuito (10 ms) es mucho más restrictivo que el de peticiones, cada servicio tiene su propia forma de medir el uso (peticiones, milisegundos de CPU, filas, operaciones, GB-s) y algunos productos, como R2, se facturan completamente aparte.

En este artículo reúno, servicio por servicio, qué incluye cada plan, qué pasa cuando superas un límite y cómo se calcula la factura, con los ejemplos de la documentación oficial reproducidos en una pequeña calculadora en TypeScript.

🧪

**Todos los precios y límites están comprobados en la documentación oficial de Cloudflare el 2 de octubre de 2026** (la página de precios de Workers se actualizó ese mismo día). La calculadora se ha ejecutado con **Node.js 24.21.0**, que ejecuta TypeScript directamente, y reproduce los ejemplos oficiales al céntimo. Los precios son en dólares y pueden cambiar: antes de decidir nada, revisa la página de precios.

## Los dos planes en una frase

- **Workers Free**: gratis, por defecto en cualquier cuenta. Límites **diarios** que se reinician a las 00:00 UTC. Si los superas, las peticiones fallan hasta el reinicio; no hay sobrecostes posibles.
- **Workers Paid**: **5 dólares al mes como mínimo** por cuenta. Cantidades incluidas **mensuales** mucho mayores y precio por uso a partir de ahí. Límites de CPU, subpeticiones y número de Workers muy superiores.

El plan de Workers es **independiente del plan de tu zona** (Free, Pro, Business). Puedes tener el dominio en el plan gratuito y Workers Paid, o al revés.

![Esquema comparativo: Workers Free con límites diarios que bloquean al superarse; Workers Paid con 5 dólares al mes, uso mensual incluido y pago por exceso](https://blog.devutilites.com/content/images/2026/10/cf-planes-esquema.png)

En Free, los límites son un muro; en Paid, un umbral a partir del cual se paga. Diagrama: devutilites.

## Workers: peticiones y CPU

|                                 | Workers Free         | Workers Paid                                            |
| ------------------------------- | -------------------- | ------------------------------------------------------- |
| Peticiones                      | 100.000 al día       | 10 millones al mes, luego 0,30 $ por millón             |
| Tiempo de CPU                   | 10 ms por invocación | 30 millones de ms al mes, luego 0,02 $ por millón de ms |
| CPU máxima por petición         | 10 ms                | 30 s por defecto, configurable hasta 5 minutos          |
| CPU en Cron Triggers            | 10 ms                | 30 s (intervalo < 1 h) o 15 minutos (≥ 1 h)             |
| Duración (tiempo de reloj)      | Sin coste            | Sin coste ni límite                                     |
| Peticiones a ficheros estáticos | Gratis e ilimitadas  | Gratis e ilimitadas                                     |

Lo más importante de esta tabla: **en Workers se paga CPU, no tiempo de reloj**. Un Worker que espera 2 segundos a una API externa y usa 3 ms de CPU paga 3 ms. Por eso Workers es tan barato para APIs que sobre todo esperan a otros servicios.

Y lo segundo más importante: **10 ms de CPU es poco**. Alcanza para la mayoría de APIs que leen de KV o D1 y devuelven JSON, pero no para renderizar páginas grandes en el servidor, procesar imágenes, comprimir ficheros o verificar ciertas firmas criptográficas. Si tu Worker supera los 10 ms en el plan gratuito, esa petición falla (error 1102). En muchos proyectos, este es el motivo real para pasar a Paid, mucho antes de llegar a las 100.000 peticiones.

### Qué se cuenta como petición

- Cada petición entrante al Worker. **Las subpeticiones** (los `fetch` que hace tu Worker) **no se cobran**.
- Una conexión WebSocket cuenta como **una** petición (la del `Upgrade`); los mensajes no.
- Las peticiones a **ficheros estáticos** no cuentan, salvo que el Worker se ejecute antes (`run_worker_first`) o actives **Workers Cache**: con la caché de Workers activada, también las respuestas servidas desde caché (incluidos estáticos) se cobran como peticiones, aunque no consuman CPU.
- Las llamadas entre Workers mediante **service bindings** no suman peticiones: pagas una petición (la del primer Worker) y la CPU de todos.

### Qué pasa al superar el límite diario en Free

Cuando la cuenta pasa de 100.000 peticiones en el día, Cloudflare devuelve el **error 1027**. Para Workers asociados a rutas de tu dominio puedes elegir el comportamiento: *fail open* (la petición sigue como si no hubiera Worker, útil si el Worker solo añade algo a tu web) o *fail closed* (página de error 1027, lo que quieres si el Worker hace de control de acceso).

## Otros límites que cambian

| Límite                                           | Workers Free | Workers Paid                            |
| ------------------------------------------------ | ------------ | --------------------------------------- |
| Subpeticiones por invocación                     | 50           | 10.000 (configurable hasta 10 millones) |
| Subpeticiones a servicios internos de Cloudflare | 1.000        | Igual que el límite configurado         |
| Variables de entorno y secretos por Worker       | 64           | 128                                     |
| Número de Workers                                | 100          | 500                                     |
| Cron Triggers por cuenta                         | 5            | 250                                     |
| Ficheros estáticos por versión                   | 20.000       | 100.000                                 |
| Memoria                                          | 128 MB       | 128 MB                                  |
| Tamaño del Worker                                | 64 MiB       | 64 MiB                                  |
| Tiempo de arranque                               | 1 s          | 1 s                                     |

En Paid, los límites de CPU y subpeticiones se ajustan **por Worker** en la configuración. Subirlos te da margen; **bajarlos** te protege de un bucle que se dispare y te genere una factura:

```json
{
  "name": "mi-api",
  "main": "src/index.ts",
  "compatibility_date": "2026-10-01",
  "limits": {
    "cpu_ms": 300000,     // hasta 5 minutos de CPU por petición (por defecto 30000)
    "subrequests": 200    // un tope más bajo que los 10.000 por defecto
  }
}
```

## Los demás servicios, plan a plan

### Workers KV

|                                 | Free                  | Paid                                              |
| ------------------------------- | --------------------- | ------------------------------------------------- |
| Lecturas                        | 100.000 al día        | 10 millones al mes, luego 0,50 $ por millón       |
| Escrituras, borrados y listados | 1.000 al día cada uno | 1 millón al mes cada uno, luego 5,00 $ por millón |
| Almacenamiento                  | 1 GB                  | 1 GB, luego 0,50 $ por GB-mes                     |

### D1

|                | Free                                     | Paid                                                    |
| -------------- | ---------------------------------------- | ------------------------------------------------------- |
| Filas leídas   | 5 millones al día                        | 25.000 millones al mes, luego 0,001 $ por millón        |
| Filas escritas | 100.000 al día                           | 50 millones al mes, luego 1,00 $ por millón             |
| Almacenamiento | 5 GB en total (500 MB por base de datos) | 5 GB, luego 0,75 $ por GB-mes (10 GB por base de datos) |

### Durable Objects

|                             | Free                         | Paid                                                  |
| --------------------------- | ---------------------------- | ----------------------------------------------------- |
| Peticiones                  | 100.000 al día               | 1 millón al mes, luego 0,15 $ por millón              |
| Duración                    | 13.000 GB-s al día           | 400.000 GB-s al mes, luego 12,50 $ por millón de GB-s |
| Almacenamiento SQLite       | Filas como D1; 5 GB en total | Filas como D1; 5 GB-mes, luego 0,20 $ por GB-mes      |
| Backend clave-valor antiguo | No disponible                | Disponible                                            |

### Queues

|                             | Free          | Paid                                     |
| --------------------------- | ------------- | ---------------------------------------- |
| Operaciones (3 por mensaje) | 10.000 al día | 1 millón al mes, luego 0,40 $ por millón |
| Retención                   | 24 horas      | 4 días por defecto, hasta 14             |

### Workers Logs y Logpush

|                | Free                                | Paid                                                             |
| -------------- | ----------------------------------- | ---------------------------------------------------------------- |
| Eventos de log | 200.000 al día, 3 días de retención | 20 millones al mes, luego 0,60 $ por millón; 7 días de retención |
| Logpush        | No disponible                       | 10 millones al mes, luego 0,05 $ por millón                      |

📅

**Workers Logs cambia de precio el 1 de diciembre de 2026.** A partir de esa fecha pasará a los precios de Cloudflare Observability, según la página de precios de Workers. Hasta entonces se aplica la tabla de arriba.

### Hyperdrive, Workers AI, Vectorize, Workflows y Containers

| Servicio   | Free                                                  | Paid                                                                                          |
| ---------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| Hyperdrive | 100.000 consultas al día                              | Consultas ilimitadas                                                                          |
| Workers AI | 10.000 neuronas al día                                | 10.000 neuronas al día gratis, luego 0,011 $ por 1.000 neuronas                               |
| Vectorize  | 30 M dimensiones consultadas al mes y 5 M almacenadas | 50 M consultadas incluidas, luego 0,01 $ por millón; 10 M almacenadas, luego 0,05 $ por 100 M |
| Workflows  | 3.000 pasos al día                                    | 500.000 pasos al mes, luego 0,80 $ por 100.000                                                |
| Containers | No disponible                                         | Uso incluido de memoria, CPU y disco, y pago por exceso                                       |

⚠️

**Dos avisos sobre esta tabla.** La documentación de Vectorize dice en un sitio que es solo para planes de pago y, en la tabla de precios, muestra cantidades para el plan gratuito; la he copiado tal cual. Y Workflows tiene publicado el precio de los pasos y el almacenamiento, pero Cloudflare indica que **no los cobrará hasta una fecha que anunciará** en su registro de cambios.

### R2 va aparte

R2 **no forma parte del plan de Workers**: tiene su propia capa gratuita mensual (10 GB, 1 millón de operaciones de clase A y 10 millones de clase B) y sus propios precios (0,015 $ por GB-mes en Standard, 4,50 $ por millón de clase A, 0,36 $ por millón de clase B, salida gratis), igual tengas Free o Paid. Eso sí, necesitas activar la suscripción de R2 con un método de pago aunque no pases de la capa gratuita.

## Calcular la factura

La documentación trae varios ejemplos para Workers. Los he reproducido con esta calculadora, que suma también KV, D1, R2 y Queues con sus cantidades incluidas:

```typescript
// Calculadora de la factura mensual de Workers Paid (precios en USD, octubre de 2026)
type Uso = {
  peticiones: number;        // peticiones al Worker (no cuentan los estáticos)
  cpuMsMedia: number;        // ms de CPU por petición
  kvLecturas?: number;
  kvEscrituras?: number;
  d1FilasLeidas?: number;
  d1FilasEscritas?: number;
  r2GB?: number;
  r2ClaseA?: number;
  r2ClaseB?: number;
  colaMensajes?: number;     // mensajes < 64 KB: 3 operaciones cada uno
};

const exceso = (usado: number, incluido: number) => Math.max(0, usado - incluido);
const r = (n: number) => Math.round(n * 100) / 100;

export function factura(u: Uso) {
  const lineas = {
    suscripcion: 5,
    peticiones: (exceso(u.peticiones, 10e6) / 1e6) * 0.3,
    cpu: (exceso(u.peticiones * u.cpuMsMedia, 30e6) / 1e6) * 0.02,
    kv: (exceso(u.kvLecturas ?? 0, 10e6) / 1e6) * 0.5 + (exceso(u.kvEscrituras ?? 0, 1e6) / 1e6) * 5,
    d1: (exceso(u.d1FilasLeidas ?? 0, 25e9) / 1e6) * 0.001 + (exceso(u.d1FilasEscritas ?? 0, 50e6) / 1e6) * 1,
    // R2 se factura aparte, con su propia capa gratuita (10 GB, 1 M clase A, 10 M clase B)
    r2:
      exceso(u.r2GB ?? 0, 10) * 0.015 +
      (exceso(u.r2ClaseA ?? 0, 1e6) / 1e6) * 4.5 +
      (exceso(u.r2ClaseB ?? 0, 10e6) / 1e6) * 0.36,
    colas: (exceso((u.colaMensajes ?? 0) * 3, 1e6) / 1e6) * 0.4,
  };
  const total = Object.values(lineas).reduce((a, b) => a + b, 0);
  return { ...Object.fromEntries(Object.entries(lineas).map(([k, v]) => [k, r(v)])), total: r(total) };
}

// Los ejemplos de la documentación oficial, para comprobar que cuadra
console.log("Docs ejemplo 1 (15 M pet., 7 ms):", factura({ peticiones: 15e6, cpuMsMedia: 7 }));
console.log("Docs ejemplo 4 (100 M pet., 7 ms):", factura({ peticiones: 100e6, cpuMsMedia: 7 }));

// Un caso realista: API de un SaaS pequeño
console.log(
  "SaaS pequeño:",
  factura({
    peticiones: 25e6, cpuMsMedia: 4,
    kvLecturas: 30e6, kvEscrituras: 200_000,
    d1FilasLeidas: 3e9, d1FilasEscritas: 5e6,
    r2GB: 120, r2ClaseA: 400_000, r2ClaseB: 8e6,
    colaMensajes: 2e6,
  }),
);
```

Node 24 ejecuta TypeScript directamente (elimina los tipos al cargar el fichero), así que no hace falta compilar:

```text
$ node coste.ts
Docs ejemplo 1 (15 M pet., 7 ms): {
  suscripcion: 5, peticiones: 1.5, cpu: 1.5, kv: 0, d1: 0, r2: 0, colas: 0, total: 8
}
Docs ejemplo 4 (100 M pet., 7 ms): {
  suscripcion: 5, peticiones: 27, cpu: 13.4, kv: 0, d1: 0, r2: 0, colas: 0, total: 45.4
}
SaaS pequeño: {
  suscripcion: 5, peticiones: 4.5, cpu: 1.4, kv: 10, d1: 0, r2: 1.65, colas: 2, total: 24.55
}
```

Los dos primeros coinciden con los de la documentación: **8,00 $** para 15 millones de peticiones al mes con 7 ms de CPU, y **45,40 $** para 100 millones. El tercero es un caso inventado pero realista: una API con 25 millones de peticiones, 30 millones de lecturas de KV, 3.000 millones de filas leídas en D1, 120 GB en R2 y 2 millones de mensajes en colas sale por unos **24,55 $ al mes**. Fíjate en que la partida más cara son las 30 millones de lecturas de KV, no las peticiones.

La calculadora es una aproximación: no aplica los redondeos a la unidad de facturación que hacen algunos servicios (R2 y Durable Objects redondean hacia arriba al millón o al GB siguiente) ni los impuestos.

Otros tres ejemplos oficiales que ayudan a hacerse una idea:

| Caso (documentación oficial)                                                     | Factura mensual                     |
| -------------------------------------------------------------------------------- | ----------------------------------- |
| 15 M de peticiones, el 80 % a ficheros estáticos, 7 ms de CPU                    | 5,00 $ (todo dentro de lo incluido) |
| Un cron cada hora con 3 minutos de CPU (720 ejecuciones)                         | 6,99 $                              |
| 100 M de peticiones, 7 ms de CPU, Workers Cache con 80 % de aciertos             | 34,20 $                             |
| Durable Objects: 100 salas con 100 WebSockets hibernables, un mensaje por minuto | 20,65 $                             |
| Queues: 1 millón de mensajes al día                                              | 35,60 $ más la suscripción          |

## ¿Cuándo pasar a Paid?

Pasa a Paid cuando te ocurra cualquiera de estas cosas:

- **Tus peticiones superan los 10 ms de CPU** (SSR, criptografía, procesado de datos). Es la razón más común.
- **Necesitas más de 50 subpeticiones** por petición (por ejemplo, una API que agrega muchas otras).
- **Te acercas a las 100.000 peticiones diarias** o a las **1.000 escrituras diarias de KV**.
- **Necesitas algo que solo está en Paid**: Containers, Logpush, más de 5 crons, retención de colas de más de 24 horas, Time Travel de 30 días en D1, el backend clave-valor de Durable Objects.
- **No puedes permitirte que el servicio se corte** al llegar al límite diario: en Paid no hay muro, solo una factura algo mayor.

Y quédate en Free mientras tu proyecto quepa: para proyectos personales, prototipos, webs estáticas con algo de API o herramientas internas, es raro necesitar más.

💡

**Mide antes de decidir.** Las métricas de cada Worker en el panel muestran las peticiones y el tiempo de CPU por invocación. Tu portátil no es un servidor de Cloudflare, así que lo más fiable para saber si tu código cabe en 10 ms es desplegarlo y mirar esas métricas con tráfico real.

## Errores comunes (y cómo evitarlos)

- **Pensar que el límite son las peticiones.** En Free, casi siempre te encontrarás antes con los 10 ms de CPU.
- **Activar Workers Cache sin hacer números.** Con la caché de Workers, también los aciertos de caché y los estáticos se cobran como peticiones. Mejora la latencia y ahorra CPU, pero puede subir la línea de peticiones.
- **Olvidar que R2 va aparte.** No está en los 5 $ del plan ni en sus cantidades incluidas.
- **Escribir en KV en cada petición.** 1.000 escrituras al día en Free; 5 $ por millón en Paid. Para contadores, Durable Objects.
- **WebSockets sin hibernación.** En Durable Objects, `accept()` cobra duración mientras la conexión esté abierta.
- **No poner topes.** `limits.cpu_ms` y `limits.subrequests` bajos en Workers que no los necesitan evitan que un error se convierta en una factura.

## Sigue leyendo

- [Cloudflare a fondo](https://blog.devutilites.com/cloudflare-a-fondo/): qué hace cada servicio y cuándo usarlo.
- [Cloudflare Workers a fondo](https://blog.devutilites.com/cloudflare-workers-a-fondo/): CPU, `waitUntil`, crons y caché, con código probado.
- [Cloudflare Workers KV a fondo](https://blog.devutilites.com/cloudflare-workers-kv-a-fondo/), [Cloudflare D1 a fondo](https://blog.devutilites.com/cloudflare-d1-a-fondo/) y [Cloudflare R2 a fondo](https://blog.devutilites.com/cloudflare-r2-a-fondo/): el almacenamiento y su precio en detalle.
- [Cloudflare Durable Objects a fondo](https://blog.devutilites.com/cloudflare-durable-objects-a-fondo/) y [Cloudflare Queues a fondo](https://blog.devutilites.com/cloudflare-queues-a-fondo/): duración, GB-s y operaciones.
- [Cloudflare Workflows a fondo](https://blog.devutilites.com/cloudflare-workflows-a-fondo/): cómo se cuentan los pasos.
- [Cloudflare Containers a fondo](https://blog.devutilites.com/cloudflare-containers-a-fondo/): solo en Paid, facturado cada 10 ms.
- [Cloudflare Workers AI a fondo](https://blog.devutilites.com/cloudflare-workers-ai-a-fondo/): las neuronas gratis de cada día en los dos planes.