# Cloudflare Workers AI 10,000 Neurons Per Day: Practical Usage and Limits Explained

> Understand Cloudflare Workers AI's 10,000 neurons per day limit. Discover practical usage for chat completions and document summaries before hitting pay-as-you-go rates.

- Repository: [Jun Siang Cheah/free-llm-api-resources](https://github.com/cheahjs/free-llm-api-resources)
- Tags: deep-dive
- Published: 2026-05-07

---

**Cloudflare Workers AI's free tier allocates 10,000 neurons per day—equivalent to roughly 10,000 tokens—supporting approximately 250 short chat completions or 3-4 large document summaries daily before pay-as-you-go pricing applies.**

The free tier limit for Cloudflare Workers AI is documented in the `cheahjs/free-llm-api-resources` repository, which tracks no-cost LLM API offerings. Understanding how these **neurons** translate to actual API calls helps developers architect applications that stay within the generous free quota or know exactly when to upgrade.

## What Are Neurons in Cloudflare Workers AI?

A **neuron** in Cloudflare's terminology represents a single token processed by the model, counting both input and output tokens. This abstraction makes the quota model-agnostic—whether you call Llama, Gemma, or Mistral, 1,000 tokens consumed equals 1,000 neurons deducted.

According to the repository data structures in [`src/data.py`](https://github.com/cheahjs/free-llm-api-resources/blob/main/src/data.py), this standardization allows the [`src/pull_available_models.py`](https://github.com/cheahjs/free-llm-api-resources/blob/main/src/pull_available_models.py) script to uniformly track limits across different providers. The [`README.md`](https://github.com/cheahjs/free-llm-api-resources/blob/main/README.md) generated from [`src/README_template.md`](https://github.com/cheahjs/free-llm-api-resources/blob/main/src/README_template.md) lists Cloudflare's specific allocation as 10,000 neurons per day, which roughly equates to 7,000–8,000 words of English text.

## Practical Usage Scenarios

The 10,000-neuron quota resets at **midnight UTC** daily and is shared across all Workers AI models. Unlike some services that rate-limit by requests per minute, Cloudflare only enforces the cumulative daily token count.

### Short Chat Completions

A typical interaction consuming 40 neurons (10-token prompt + 30-token reply) allows approximately **250 conversations per day**. This suits FAQ bots or lightweight assistance tools.

### Document Summarization

Processing a 2,000-token document with a 200-token summary consumes 2,200 neurons, limiting you to **4–5 summarizations daily**. For larger 3,000-token inferences, expect roughly **3 runs per day**.

### Code Generation

Generating 1,000 tokens of code (500-token prompt + 500-token output) uses 1,000 neurons, permitting about **10 code generations daily** on the free tier.

## Monitoring Neuron Consumption in Code

To avoid hitting the 10,000-neuron ceiling unexpectedly, inspect the `usage` field in API responses. Both Cloudflare Workers scripts and external Python applications can track consumption in real-time.

### JavaScript Worker Example

The following Worker script forwards requests to Workers AI and logs neuron usage:

```javascript
// workers/ai.js – Serverless function tracking token consumption
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const { prompt } = await request.json()
  const aiResponse = await fetch('https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/ai/run', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${AI_TOKEN}`,   // Stored in Worker secrets
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: '@cf/meta/llama-2-7b-chat',
      prompt,
    })
  })
  const data = await aiResponse.json()
  const totalNeurons = data.usage.input_tokens + data.usage.output_tokens
  console.log(`Consumed ${totalNeurons} neurons for this call`)
  return new Response(JSON.stringify(data), { status: 200 })
}

```

### Python Client Example

When calling the REST API from Python, aggregate `input_tokens` and `output_tokens` to calculate total neuron expenditure:

```python
import requests
import os

account_id = "your_account_id"
url = f"https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run"

payload = {
    "model": "@cf/google/gemma-4-26b-a4b-it",
    "prompt": "Explain the concept of neurons in Cloudflare AI."
}

headers = {
    "Authorization": f"Bearer {os.getenv('CF_AI_TOKEN')}",
    "Content-Type": "application/json"
}

r = requests.post(url, json=payload, headers=headers)
data = r.json()

neurons = data["usage"]["input_tokens"] + data["usage"]["output_tokens"]
print(f"Neurons used: {neurons}")
print(data["result"])

```

## Repository Implementation Details

The `cheahjs/free-llm-api-resources` repository maintains Cloudflare's limits across several key files:

- **[`README.md`](https://github.com/cheahjs/free-llm-api-resources/blob/main/README.md)**: Contains the summary table displaying the 10,000 neurons/day allocation for quick reference.
- **[`src/pull_available_models.py`](https://github.com/cheahjs/free-llm-api-resources/blob/main/src/pull_available_models.py)**: Generates the provider-specific documentation section that includes the neuron limit and links to official Cloudflare pricing.
- **[`src/data.py`](https://github.com/cheahjs/free-llm-api-resources/blob/main/src/data.py)**: Defines the data structures storing model metadata, including the unified limit format used to track Cloudflare's offering alongside other providers.
- **[`src/README_template.md`](https://github.com/cheahjs/free-llm-api-resources/blob/main/src/README_template.md)**: Provides the template scaffolding where the neuron limit is injected during the documentation build process.

## Summary

- **10,000 neurons equals approximately 10,000 tokens** (input + output), or roughly 7,000–8,000 words.
- The quota is **shared across all Workers AI models** and **resets at midnight UTC**.
- You can make roughly **250 short API calls** or **3–4 large document processing tasks** per day on the free tier.
- Exceeding the limit triggers **pay-as-you-go pricing** (approximately $0.50 per million tokens).
- Monitor consumption via the `usage` field in API responses to prevent unexpected billing.

## Frequently Asked Questions

### How many API requests can I make per day with Cloudflare Workers AI?

The number of requests depends entirely on token consumption per call. With 10,000 neurons available, you could make roughly 250 requests if each consumes 40 tokens (short prompts and replies), or only 3 requests if each consumes 3,000 tokens (large document analysis). There is no separate request limit—only the cumulative neuron count matters.

### What's the difference between neurons and tokens in Cloudflare Workers AI?

**Neurons are Cloudflare's abstraction for tokens**, where one neuron equals one token. This standardization ensures that the 10,000-neuron quota applies uniformly whether you use Llama, Gemma, Mistral, or other supported models, making capacity planning straightforward across different architectures.

### Does the 10,000 neuron quota reset every 24 hours?

The quota resets at **midnight UTC**, not on a rolling 24-hour basis. If you exhaust your allocation at 3 PM UTC, you must wait until midnight UTC for the counter to reset, rather than waiting 24 hours from your last request.

### What happens when I exceed the free neuron limit?

Once you consume more than 10,000 neurons in a day, subsequent requests are billed at Cloudflare's standard pay-as-you-go rates. The platform does not hard-block you but rather transitions your account to paid pricing for additional tokens consumed that day.