La Forma Más Barata de Ejecutar un Agente de Contenido en Cloudflare

Tabla de contenidos

Actualizado mayo 2026.

TL;DR: Puedes ejecutar un pipeline completo de generación de contenido y traducción en Cloudflare Workers + Claude API por aproximadamente $0,50 por post con Sonnet 3.5, o $0,12 con Haiku. El nivel gratuito de Cloudflare gestiona 100K solicitudes/día — solo pagas cuando la escala lo exige. La limitación es la latencia de arranque en frío para llamadas LLM de larga duración, que Queues resuelve.

[Lectura del operador] Ejecuto exactamente este pipeline para alejandrorioja.com: un Worker de TypeScript escribe un post, distribuye 12 trabajos de traducción y almacena todo en KV — todo activado por una sola llamada HTTP. Aquí está exactamente lo que cuesta y cómo está configurado.

Por qué Cloudflare en lugar de AWS o Vercel

AWS Lambda cobra por GB-segundo de cómputo. Vercel cobra por ejecución y tiene límites de velocidad agresivos en el nivel gratuito. Ambos añaden imprevisibilidad en los arranques en frío a escala.

Cloudflare Workers se ejecuta en aisladores V8, no en contenedores. Los arranques en frío son de submilisegundo. El nivel gratuito es genuinamente útil: 100.000 solicitudes por día, 10ms de tiempo de CPU por solicitud (el tiempo de reloj de pared es mayor). El plan de pago es $5/mes para 10 millones de solicitudes.

Para un pipeline de contenido IA, el costo de cómputo de Workers es casi cero. El costo real es la API de Claude. Esa es la única variable que necesitas optimizar.

La arquitectura (diagrama de texto)

Disparador HTTP (cron o webhook)
        │
        ▼
  Worker: orquestador
        │
        ├─ Escribir metadatos del trabajo → KV (estado: "pending")
        │
        └─ Encolar 1 trabajo de generación EN
               │
               ▼
         Cola: content-jobs
               │
        ┌──────┴──────┐
        ▼             ▼
  Worker: escritor   Worker: traductor (×12 locales)
        │                    │
        ▼                    ▼
  Claude API             Claude API
        │                    │
        └──────┬─────────────┘
               ▼
        KV: posts/{slug}/{locale}
               │
               ▼
     Webhook → GitHub → despliegue

El Worker orquestador es el punto de entrada. Escribe un registro de estado inicial en KV, luego empuja un trabajo a una Cola de Cloudflare. El fan-out de la Cola genera el Worker escritor (EN) y, una vez que el cuerpo EN está listo, 12 Workers traductores en paralelo. Todo aterriza en KV con clave {slug}/{locale}. Un webhook final activa un despliegue de GitHub Actions.

Tabla de costos de Cloudflare

Para un sitio que publica 10 posts/mes, la factura de Cloudflare es $0 en el nivel gratuito. Los Workers son gratis. Las lecturas/escrituras KV a ese volumen son gratis. La única función de pago que uso es Queues — que requiere el plan Workers Paid de $5/mes, pero ese plan incluye 1M de mensajes en cola.

Mi factura de Cloudflare: $5/mes fijo, independientemente del volumen de posts hasta ~3.000 posts/mes.

Tabla de costos de la API de Claude

Aquí es donde va el dinero real. Aquí está el desglose por post.

Generación EN (un post, ~1.500 palabras):

12 traducciones (cada una ~1.500 palabras):

Total por post (EN + 12 traducciones):

Uso Sonnet para la generación EN (la calidad importa para el post canónico) y Haiku para las traducciones (el texto fuente ya está escrito; el modelo solo necesita traducirlo fielmente). Ese enfoque mixto cuesta aproximadamente $0,10 por post en la práctica.

Worker TypeScript: el orquestador

// src/workers/orchestrator.ts
import { Queue } from "@cloudflare/workers-types";

interface Env {
  CONTENT_QUEUE: Queue;
  POSTS_KV: KVNamespace;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { slug, topic } = await request.json<{ slug: string; topic: string }>();

    // Escribir estado inicial
    await env.POSTS_KV.put(
      `status:${slug}`,
      JSON.stringify({ status: "pending", createdAt: Date.now() })
    );

    // Encolar el trabajo de generación EN
    await env.CONTENT_QUEUE.send({
      type: "generate",
      slug,
      topic,
      locale: "en",
    });

    return Response.json({ queued: true, slug });
  },
};

Worker TypeScript: el escritor + traductor

// src/workers/content-processor.ts
interface Env {
  CONTENT_QUEUE: Queue;
  POSTS_KV: KVNamespace;
  ANTHROPIC_API_KEY: string;
}

const LOCALES = ["ar","de","es","fr","hi","it","ja","ko","nl","pt","ru","zh"];

export default {
  async queue(batch: MessageBatch<ContentJob>, env: Env): Promise<void> {
    for (const msg of batch.messages) {
      const job = msg.body;

      if (job.type === "generate") {
        const post = await generatePost(job.topic, env.ANTHROPIC_API_KEY);
        await env.POSTS_KV.put(`post:${job.slug}:en`, post);

        // Distribuir traducciones
        for (const locale of LOCALES) {
          await env.CONTENT_QUEUE.send({
            type: "translate",
            slug: job.slug,
            locale,
            sourceText: post,
          });
        }
      }

      if (job.type === "translate") {
        const translated = await translatePost(
          job.sourceText,
          job.locale,
          env.ANTHROPIC_API_KEY,
          // Usar Haiku para traducciones para reducir costos
          "claude-haiku-3-5-20241022"
        );
        await env.POSTS_KV.put(`post:${job.slug}:${job.locale}`, translated);
      }

      msg.ack();
    }
  },
};

async function generatePost(topic: string, apiKey: string): Promise<string> {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": apiKey,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model: "claude-sonnet-3-5-20241022",
      max_tokens: 4096,
      messages: [{ role: "user", content: `Write a detailed blog post about: ${topic}` }],
    }),
  });
  const data = await res.json<{ content: Array<{ text: string }> }>();
  return data.content[0].text;
}

async function translatePost(
  text: string,
  locale: string,
  apiKey: string,
  model: string
): Promise<string> {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": apiKey,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model,
      max_tokens: 4096,
      messages: [
        {
          role: "user",
          content: `Translate the following blog post to ${locale}. Preserve all markdown. Keep code blocks in English.\n\n${text}`,
        },
      ],
    }),
  });
  const data = await res.json<{ content: Array<{ text: string }> }>();
  return data.content[0].text;
}

Comparación de alternativas

El servidor propio es el único caso donde Cloudflare pierde. Un VPS de Hetzner a $6/mes ejecuta Node 24/7 sin arranques en frío y sin costo por solicitud. Pero gestionas despliegues, tiempo de actividad y escalado tú mismo. Workers maneja todo eso gratis a mi volumen.

La comparación con AWS Lambda suena competitiva en papel, pero el límite máximo de ejecución de 15 minutos de Lambda es un límite real para cadenas LLM largas. Workers tiene un límite de CPU de 30 segundos en el plan de pago — que suena peor pero está bien porque usas Queues para trabajo asíncrono, no bloqueando un solo Lambda.

KV para gestión de estado

KV es el almacén clave-valor distribuido globalmente de Cloudflare. Las lecturas son rápidas en todas partes (caché en el borde). Las escrituras se propagan globalmente en menos de 60 segundos.

Para un pipeline de contenido, uso tres patrones de clave:

// Estado del trabajo
await kv.put(`status:${slug}`, JSON.stringify({ status, updatedAt: Date.now() }));

// Contenido del post
await kv.put(`post:${slug}:${locale}`, markdownContent);

// Índice para listar
const index = await kv.get<string[]>("index:posts", "json") ?? [];
await kv.put("index:posts", JSON.stringify([...index, slug]));

Costos de KV a mi escala: $0. El nivel gratuito da 1K escrituras/día y 100K lecturas/día. Escribo ~300 entradas KV por mes (25 posts × 13 locales = 325). Muy lejos del límite.

Si publicas 100+ posts/mes en 12 locales, alcanzarías ~39.000 escrituras/mes — aún por debajo del 1M/mes incluido en el plan de pago de $5.

El resultado final del operador

Mi pipeline completo de contenido — generar, traducir, almacenar, desplegar — cuesta $5,10/mes en infraestructura ($5 Cloudflare Workers Paid + $0,10 API de Claude por post a 10 posts/mes). Eso es todo. Sin servidores que gestionar, sin orquestación de contenedores, sin facturas sorpresa de Lambda con arranques en frío alcanzando un umbral de concurrencia provisionada.

La estrategia de modelo mixto (Sonnet para EN, Haiku para traducciones) reduce los costos de Claude en un 80% sin ninguna caída perceptible en la calidad de las traducciones. Calcula los números para tu volumen y encontrarás que Cloudflare + Claude Haiku es genuinamente la forma más barata de ejecutar este tipo de pipeline a escala de fundador.