Workers AI Komplett-Tutorial: 10.000 kostenlose LLM-Aufrufe pro Tag – bis zu 90 % günstiger als OpenAI

Meine OpenAI-API-Rechnung stieg einmal auf über 200 US-Dollar im Monat – nur wegen ein paar Tagen Tests in einem kleinen Projekt. Workers AI habe ich beim Erkunden der Cloudflare-Edge-Funktionen ausprobiert: 10.000 Neurons pro Tag gratis, eine Woche im Alltag getestet – für normale Dialogmengen reicht das.

Dieser Artikel erklärt drei Aufrufarten für Workers AI und welche Konfiguration Sie bei der Migration von OpenAI anpassen müssen.

Was ist Workers AI – und warum lohnt sich ein Blick?

Kurz gesagt: Workers AI ist der serverlose KI-Inferenzdienst von Cloudflare. Kein eigener GPU-Kauf, kein Server-Betrieb – mit wenigen Zeilen Code rufen Sie Llama, Mistral und andere Open-Source-LLMs auf.

Die drei wichtigsten Punkte:

1. 10.000 Neurons pro Tag kostenlos

   • Im Test reichen das für einige hundert Dialoge – persönliche Projekte sind abgedeckt
   • Mit Llama 3.1-8B: 1.000 einfache Dialoge verbrauchten bei mir etwa 8.000 Neurons

2. Bezahlter Preis: $0,011/1.000 Neurons

   • 60–70 % günstiger als OpenAI GPT-3.5
   • über 90 % günstiger als GPT-4

3. Globales Edge-Netzwerk

   • Cloudflare mit 300+ Knoten
   • Antwortzeiten oft schneller als bei vielen Cloud-Anbietern

Vergleich mit anderen Optionen

„Kostenlos“ klingt verdächtig? Hier eine Übersicht:

Wann passt Workers AI?

• ✅ Persönliche Projekte, Prototypen, Lernexperimente
• ✅ Kleine bis mittlere Produktions-Apps (QPS < 300)
• ✅ Kostenbewusste Start-ups

Wann eher nicht?

• ⚠️ Massenverarbeitung (Hunderttausende Aufrufe/Tag)
• ⚠️ Extrem latenzkritisch (< 100 ms Antwort)
• ⚠️ Wenn Sie zwingend GPT-4-Niveau brauchen

"Llama 3.1-8B mit chinesischen Dialogen (Praxistest): einfache Q&A (unter 100 Zeichen) ~5–8 Neurons; lange Zusammenfassung (~1.000 Zeichen Input) ~30–50 Neurons; Code-Generierung (~500 Zeilen) ~20–40 Neurons."

Reicht das Gratis-Kontingent? Eine kurze Rechnung

„Neurons“ ist Cloudflares eigene Abrechnungseinheit – am Anfang wirkt das ungewohnt. Vereinfacht:

Neurons = (Input-Tokens + Output-Tokens) × Modellfaktor

Modellfaktoren (Beispiele):

• Llama 3.1-8B: Faktor ~0,8
• Llama 3.1-70B: Faktor ~3,5
• Mistral 7B: Faktor ~0,7

Wie viele Aufrufe pro Tag?

Bei typischem Verbrauch decken 10.000 Neurons/Tag ungefähr ab:

Vultr - Hochleistungs-NVMe-Cloud-Server mit 32 Standorten weltweit, Docker per Klick

Preise ansehen →Anzeige

• 1.000–2.000 einfache Dialoge
• 200–300 lange Textverarbeitungen
• 250–500 Code-Generierungen

Für Einzelentwickler ist das in der Praxis sehr großzügig. Ich betreibe einen kleinen Bot mit Workers AI – einige hundert Nachrichten täglich, alles im Gratis-Kontingent.

Was passiert bei Überschreitung?

Automatischer Wechsel in den Bezahlmodus: $0,011/1.000 Neurons.

Beispielrechnung:

• 50.000 Neurons/Tag (5× Gratis)
• Überschuss: 40.000 Neurons
• Kosten: 40.000 / 1.000 × $0,011 = $0,44/Tag
• Monat: ca. $13

OpenAI bei gleichem Volumen: eher $50–100 – Workers AI ist deutlich günstiger.

Schnellstart: drei Wege zu Workers AI

Voraussetzungen:

1. Kostenloses Cloudflare-Konto
2. Node.js (für Weg 2 und 3)

Drei Aufrufarten – von einfach bis fortgeschritten.

Weg 1: Am einfachsten – REST API

Schnellster Einstieg: ohne eigenes Projekt, Test per curl.

Schritt 1: API Token und Account ID

1. Bei https://dash.cloudflare.com anmelden
2. In der URL https://dash.cloudflare.com/xxxxxxxxx – die xxxxxxxxx ist Ihre Account ID
3. Profil → My Profile → API Tokens
4. „Create Token“ → Vorlage „Workers AI“ → „Use template“
5. Token wird einmal angezeigt – sofort sichern

Schritt 2: Testaufruf

Terminal (Account ID und Token ersetzen):

curl https://api.cloudflare.com/client/v4/accounts/{Ihre_Account_ID}/ai/run/@cf/meta/llama-3.1-8b-instruct \
  -H "Authorization: Bearer {Ihr_API_Token}" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "system", "content": "Du bist ein freundlicher KI-Assistent"},
      {"role": "user", "content": "Erkläre Cloudflare Workers AI in einem Satz"}
    ]
  }'

Erfolg sieht etwa so aus:

{
  "result": {
    "response": "Cloudflare Workers AI ist eine serverlose KI-Inferenzplattform..."
  },
  "success": true
}

Häufige Fehler:

• 7003: Token oder Account ID falsch – vollständig kopieren
• 10000: Modellname falsch – @cf/meta/llama-3.1-8b-instruct inkl. @cf/
• Timeout: Erster Aufruf kann langsam sein (Cold Start), danach schneller

Weg 2: Empfohlen – Workers + Wrangler

Offiziell empfohlen: dauerhafte API, einfachere Konfiguration.

Schritt 1: Wrangler CLI

npm install -g wrangler

Anmeldung:

wrangler login

Browser-Autorisierung bestätigen.

Railway - Moderne Deployment-Plattform, ohne DevOps-Aufwand, in Minuten live

Jetzt starten →Anzeige

Schritt 2: Worker-Projekt

npm create cloudflare@latest my-ai-worker

Typische Auswahl:

• Project type: „Hello World“ Worker
• TypeScript: nach Geschmack (hier: No / JavaScript)
• Git: Yes
• Deploy: zuerst No, nach Test deployen

Schritt 3: Workers-AI-Binding

In wrangler.toml am Ende:

[ai]
binding = "AI"

Danach Zugriff über env.AI – kein manuelles Token in Code nötig.

Schritt 4: Code

src/index.js (oder index.ts):

export default {
  async fetch(request, env) {
    // CORS (für Browser-Aufrufe)
    if (request.method === 'OPTIONS') {
      return new Response(null, {
        headers: {
          'Access-Control-Allow-Origin': '*',
          'Access-Control-Allow-Methods': 'POST',
          'Access-Control-Allow-Headers': 'Content-Type',
        },
      });
    }

    if (request.method !== 'POST') {
      return new Response('Method not allowed', { status: 405 });
    }

    try {
      const { messages } = await request.json();

      const response = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
        messages: messages || [
          { role: 'user', content: 'Hello!' }
        ]
      });

      return new Response(JSON.stringify(response), {
        headers: {
          'Content-Type': 'application/json',
          'Access-Control-Allow-Origin': '*',
        },
      });

    } catch (error) {
      return new Response(JSON.stringify({ error: error.message }), {
        status: 500,
        headers: { 'Content-Type': 'application/json' },
      });
    }
  },
};

Schritt 5: Lokal testen

wrangler dev

Server z. B. http://localhost:8787:

curl http://localhost:8787 \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Stell dich kurz vor"}
    ]
  }'

Schritt 6: Produktion

wrangler deploy

Ergebnis: https://my-ai-worker.your-name.workers.dev – Ihre KI-API-URL.

Weg 3: OpenAI SDK – nahezu ohne Codeänderung

Wer OpenAI nutzt, wechselt am schnellsten: Workers AI bietet einen kompatiblen Endpunkt – vor allem baseURL anpassen.

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.CLOUDFLARE_API_TOKEN,
  baseURL: `https://api.cloudflare.com/client/v4/accounts/${process.env.ACCOUNT_ID}/ai/v1`,
});

const chatCompletion = await client.chat.completions.create({
  model: '@cf/meta/llama-3.1-8b-instruct',
  messages: [
    { role: 'system', content: 'Du bist ein freundlicher KI-Assistent' },
    { role: 'user', content: 'Hello!' }
  ],
});

console.log(chatCompletion.choices[0].message.content);

Hinweise:

• apiKey: Cloudflare API Token
• baseURL: Workers-AI-Endpunkt
• model: Workers-AI-Modell mit @cf/-Präfix

Ein Next.js-Projekt mit OpenAI migrierte ich in ~10 Minuten – nur diese drei Stellen.

Welche Modelle – und wann welches?

50+ Modelle; hier die häufigsten für Text:

Alibaba Cloud - Top-Wahl für Entwickler, exklusiv 15 % Rabatt auf Lighthouse-Server

15 % Rabatt sichern →Anzeige

Textgenerierung

Empfehlung:

1. Einstieg: Llama 3.1-8B

   • 1–2 s Antwort
   • Qualität vergleichbar mit GPT-3.5
   • Geringer Neuron-Verbrauch

2. Höhere Ansprüche: Llama 3.1-70B oder DeepSeek-R1

   • Näher an GPT-4
   • 3–5 s, ~3–4× Verbrauch

3. Lange Dokumente: Mistral 7B v0.2

   • 32k Kontext (Llama 3.1: 8k)
   • Papers, große Codebasen

Praxis: drei Beispiele

Beispiel 1: Q&A-API für Blog/Docs

Szenario: KI-Assistent für Dokumentation oder Blog.

export default {
  async fetch(request, env) {
    const corsHeaders = {
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Methods': 'POST, OPTIONS',
      'Access-Control-Allow-Headers': 'Content-Type',
    };

    if (request.method === 'OPTIONS') {
      return new Response(null, { headers: corsHeaders });
    }

    try {
      const { question } = await request.json();

      const messages = [
        {
          role: 'system',
          content: 'Du bist der KI-Assistent eines Tech-Blogs. Beantworte Fragen zu Web-Entwicklung und KI-Anwendungen – kurz und freundlich.'
        },
        {
          role: 'user',
          content: question
        }
      ];

      const response = await env.AI.run(
        '@cf/meta/llama-3.1-8b-instruct',
        { messages }
      );

      return new Response(
        JSON.stringify({ answer: response.response }),
        { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
      );

    } catch (error) {
      return new Response(
        JSON.stringify({ error: 'Verarbeitung fehlgeschlagen, bitte später erneut versuchen' }),
        { status: 500, headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
      );
    }
  }
};

Kosten: 200 Nutzer/Tag × ~10 Neurons ≈ 2.000 Neurons – im Gratis-Kontingent.

Beispiel 2: Batch-Zusammenfassungen

Szenario: RSS, News-Feeds, Artikel-Archiv.

async function generateSummary(text, env) {
  const messages = [
    {
      role: 'system',
      content: 'Du fasst Artikel in 2–3 Sätzen zusammen und hebst die Kernaussage hervor.'
    },
    {
      role: 'user',
      content: `Fasse folgenden Artikel zusammen:\n\n${text}`
    }
  ];

  const response = await env.AI.run(
    '@cf/meta/llama-3.1-8b-instruct',
    {
      messages,
      max_tokens: 150
    }
  );

  return response.response;
}

Rate Limits: Llama 3.1-8B ~300 Requests/Minute – bei Batch Jobs Verzögerung oder Queue.

Kostenbeispiel: ~1.000 Zeichen Input, ~100 Zeichen Summary → ~30 Neurons; 300 Artikel ≈ 9.000 Neurons – noch gratis.

Beispiel 3: Übersetzungsdienst

Szenario: Übersetzungstool oder i18n in der App.

async function translate(text, targetLang, env) {
  const messages = [
    {
      role: 'system',
      content: `Du übersetzt in ${targetLang} und behältst Stil und Ton. Nur die Übersetzung ausgeben, ohne Erklärung.`
    },
    {
      role: 'user',
      content: text
    }
  ];

  const response = await env.AI.run(
    '@cf/meta/llama-3.1-8b-instruct',
    { messages }
  );

  return response.response;
}

Kostenvergleich:

• Google Cloud Translation API: $20/Mio. Zeichen
• Workers AI (Llama 3.1): ca. $1,65/Mio. Zeichen

Fazit: Lohnt sich Workers AI?

Nach einem Monat Test: für Einzelentwickler und kleine Teams sehr empfehlenswert.

Vorteile:

• ✅ Großzügiges Gratis-Kontingent (10.000 Neurons/Tag)
• ✅ Günstiger Bezahlpreis (60–90 % unter OpenAI)
• ✅ Einfacher Einstieg (REST + OpenAI-kompatibel)
• ✅ Schnelle Antworten (globales Edge-Netz)
• ✅ 50+ Open-Source-Modelle

Empfehlung:

1. Persönliche Projekte: direkt nutzen – Gratis reicht, keine Server-Kosten
2. Start-ups: gut für den Start, bei Skalierung ggf. andere Plattform prüfen
3. Enterprise: SLA, Compliance und Support separat bewerten

Wenn Sie eine günstige KI-Lösung suchen: Cloudflare-Konto in 5 Minuten, erstes Beispiel in ~15 Minuten – ein Versuch lohnt sich.