Hetzner Free AI Inference API: How to Use Europe's Newest Zero-Cost LLM Endpoint in 2026

Hetzner — the German hosting company known for aggressively priced dedicated servers — launched an experimental, free Inference API in July 2026 that lets anyone run an open-source large language model through an OpenAI-compatible endpoint at zero cost during the experiment. The current model is Qwen/Qwen3.6-35B-A3B-FP8, a Mixture-of-Experts model from Alibaba's Qwen team with 35 billion total parameters (3 billion active per token), a 262,144-token context window, and multimodal vision support. You need nothing but a Hetzner account and a generated API token to start calling it from any OpenAI-compatible SDK.

Last verified: 2026-08-12 · Free while experimental · No SLA · EU data centers · OpenAI-compatible · Rate limits: 3M input / 60K output tokens per 60 seconds

Volatile facts: Pricing, models, and limits may change once the experiment ends. Hetzner has not published future token prices. Always re-check the official docs before production use.

Hetzner's Inference API is an experimental, OpenAI-compatible REST endpoint that serves open-source large language models on Hetzner's own infrastructure in Germany and Finland. It was announced on July 24, 2026, as part of Hetzner's new "experiments" platform — a forward-looking space for testing products the company may eventually offer commercially.

The API is simple: you create a token at experiments.hetzner.com/inference, point any OpenAI-compatible SDK at the base URL https://inference.hetzner.com/api/v1, and send standard chat completion requests. No GPU to rent, no model to download, no inference server to configure. Hetzner handles serving, batching, and scaling behind the scenes.

The key fact: it is free of charge while it remains in experimental status. Hetzner explicitly states that if the status changes, they will notify users in advance via email with detailed information about any billing changes (Hetzner Docs, Inference API).

Important caveat: Hetzner describes the service as "as is" with no guaranteed performance or availability, especially during high demand. No backups are created. The company explicitly says not to use the platform for production environments. This is a testing and prototyping tool, not a backend for a paying customer app.

As of August 2026, the Hetzner Inference API serves a single model: Qwen/Qwen3.6-35B-A3B-FP8.

This is a small-but-capable model. The MoE architecture means only 3 billion parameters fire for any given token, which makes inference fast and cheap — but the full 35B knowledge base is available when the routing network selects the right experts. FP8 quantization halves memory usage compared to FP16 without major quality loss, and the 256K context window is generous for a model this size, supporting long documents and extended conversations.

Hetzner says they chose a single model deliberately: "We are starting with a single high-quality model to validate the platform, gather feedback, and ensure reliability. Additional models will be added based on demand and operational experience" (Hetzner Docs).

Independent testing by Sliplane.io on July 23, 2026 reported a 153 ms median time-to-first-token across seven short requests and 224 output tokens per second across five longer generations capped at 512 tokens — though the tester cautioned this is a single-client snapshot, not an SLA (Sliplane.io, Hetzner Inference: First Look).

Go to experiments.hetzner.com/inference and sign in with a Hetzner Cloud account (creating one is free). Click the red "Create API Token" button in the top-right corner. Copy the token immediately — you will not be able to see it again.

pip install openai
python
from openai import OpenAI

client = OpenAI(
    base_url="https://inference.hetzner.com/api/v1",
    api_key="YOUR_HETZNER_TOKEN",
)

That is the only configuration change from a standard OpenAI client. The base URL switches the endpoint; everything else works the same way.

response = client.chat.completions.create(
    model="Qwen/Qwen3.6-35B-A3B-FP8",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What are the three laws of thermodynamics?"},
    ]
)

print(response.choices[0].message.content)
response = client.chat.completions.create(
    model="Qwen/Qwen3.6-35B-A3B-FP8",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in detail."},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/photo.jpg"},
                },
            ],
        }
    ]
)

print(response.choices[0].message.content)

The model supports multimodal input — you can send images alongside text in the same request. This makes it useful for tasks like describing photos, extracting text from screenshots, or analyzing diagrams.

Hetzner enforces per-key rate limits to ensure fair usage. Exceeding any limit returns HTTP 429.

Source: Hetzner Docs, Inference API — FAQ

The 24-hour input limit of 500 million tokens is extremely generous for a free service. To put it in perspective, if your average request uses 2,000 input tokens (a typical chat with a system prompt and a few messages), that is 250,000 requests per day before hitting the cap. The output limit of 5 million tokens per day is more restrictive but still covers a substantial volume of generation work.

The per-minute output cap of 60,000 tokens is the more likely bottleneck for sustained use. At 224 tokens/second (the Sliplane.io measurement), you would exhaust the 60K output budget in about 4.5 seconds of continuous generation — but in practice, requests arrive in bursts with thinking time between them, and the limit resets every 60 seconds.

No — not as of August 2026. Hetzner explicitly states the API is not for production use:

What it is good for right now:

If you want a production-grade path, read our guide on the cheapest AI API subscription deals for open-weight models in 2026 — several providers offer stable, SLA-backed endpoints for under $20/month.

The free AI inference landscape in 2026 is surprisingly competitive. Here is how Hetzner stacks up against other notable free-tier providers:

Sources: Hetzner Docs, Groq Console Docs, Cerebras Cloud, Google AI for Developers, OpenRouter Pricing, NVIDIA NIM, HuggingFace

Hetzner's unique advantages:

Where Hetzner falls short:

One of the most compelling uses of a free inference API is running AI coding agents — tools like OpenCode, Claude Code, or open-source agent frameworks that make many LLM calls in a single session. But agents that can write and execute code also pose a security risk: a buggy or hallucinated command could delete files, leak secrets, or escape into your host system.

This is where Docker Sandboxes come in. Docker launched a new product in early 2026 that runs AI coding agents inside isolated microVMs — each with its own kernel, Docker daemon, filesystem, and network. The sbx CLI is free to use, including for commercial work (Docker Docs, Sandboxes).

Traditional Docker containers share a single kernel with the host operating system. That is fine for trusted code, but AI-generated code is fundamentally untrusted — an LLM can produce a rm -rf command, mount a sensitive path, or try to escape via a kernel vulnerability. A microVM provides hardware-level isolation: the agent gets its own kernel, so even a full container escape inside the VM cannot reach the host or other sandbox sessions.

Source: Docker Blog, Why MicroVMs: The Architecture Behind Docker Sandboxes, Docker Docs, Sandboxes

Docker built a custom VMM from scratch rather than using AWS's Firecracker (the microVM engine behind Lambda) because Firecracker was designed for cloud Linux/KVM environments and has no native macOS or Windows support. Docker's custom VMM runs natively on all three platforms — Apple Hypervisor.framework on macOS, Windows Hypervisor Platform on Windows, and KVM on Linux — from a single codebase (Docker Blog).

brew install docker/tap/sbx

curl -fsSL https://get.docker.com | sudo REPO_ONLY=1 sh
sudo apt-get install docker-sbx
sudo usermod -aG kvm $USER
newgrp kvm

sbx login
cd ~/my-project
sbx run claude

The agent runs inside an isolated microVM with its own Docker daemon, filesystem, and network. If it goes rogue, the blast radius is limited to the disposable VM — your host machine is untouched. For more on running agents securely, see our guide on how to make AI coding agents work for your whole engineering team.

Hetzner is not primarily a GPU company. Their reputation comes from cheap dedicated CPU servers and managed cloud instances, not from running AI accelerator clusters. Their current GPU lineup consists of just two dedicated server models:

Source: Hetzner GEX131 product page, gpuhosted.com Hetzner GPU Review

Hetzner has never offered A100, H100, or SXM datacenter-class GPUs. Their GPU servers use workstation cards in single-socket configurations, with one GPU per server and no InfiniBand or multi-node clustering. This makes them suitable for always-on inference and fine-tuning workloads but not for distributed training of frontier models.

The Inference API experiment does not necessarily run on these public GEX servers. Hetzner may use entirely different internal hardware for the managed endpoint — the public dedicated server catalog does not prove what powers the experiment. What the experiment does signal is Hetzner testing the waters: if they see demand and can maintain quality, they may invest in larger GPU clusters for a commercial inference product down the line.

For developers and builders: The Hetzner Inference API is the lowest-friction way to test an open-source MoE model with a real agent workflow at zero cost. Create an account, generate a token, point your existing OpenAI SDK at a new base URL, and you are running inference. Pair it with Docker Sandboxes for agent isolation, and you have a complete, free local development environment for AI agents.

For small businesses: Use the free endpoint to prototype AI features — chatbots, document analyzers, image description tools — without committing to a paid API. When the experiment ends or your traffic grows, the OpenAI-compatible interface means you switch providers by changing two config values (base URL and API key). Your application code does not change. For a deeper look at budget-friendly options, our guide to AI automation business lessons that actually worked covers real implementations and their costs.

For teams with EU data residency requirements: Hetzner's German and Finnish data centers give you a GDPR-friendly free inference path that US-based providers like Groq, Cerebras, and OpenRouter cannot match by default. But do not conflate "EU-hosted" with "GDPR-compliant" — you still need a signed DPA and clear data-retention terms before sending regulated personal data to any third-party API, experimental or not.

Q: Is the Hetzner Inference API really free?

A: Yes. As long as the API remains in experimental status, it is free of charge. Hetzner states they will notify users in advance via email before introducing any billing. No credit card is required — only a free Hetzner account and a generated API token. (Source: Hetzner Docs)

Q: Which model is available on the Hetzner Inference API?

A: The only model currently served is Qwen/Qwen3.6-35B-A3B-FP8, a Mixture-of-Experts model from Alibaba's Qwen team with 35 billion total parameters, 3 billion active per token, a 262,144-token context window, and text-plus-image (vision) input support. It is quantized to FP8 and released under the Apache 2.0 license. (Sources: Hetzner Docs, Hugging Face)

Q: Can I use the Hetzner Inference API in production?

A: No. Hetzner explicitly states the service is experimental, offered "as is," with no guaranteed performance or availability, no backups, and no SLA. It should not be used for production environments. It is designed for testing, prototyping, and gathering feedback. (Source: Hetzner Docs)

Q: Is the Hetzner Inference API OpenAI-compatible?

A: Yes. The API follows the OpenAI REST API format. You can use any OpenAI-compatible SDK (Python, Node.js, Go, etc.) by simply changing the base URL to https://inference.hetzner.com/api/v1 and using your Hetzner token as the API key. Standard chat completions, streaming (with caveats), and multimodal image inputs are supported. (Source: Hetzner Docs)

Q: What are the rate limits on the Hetzner Inference API?

A: Per API key: 3 million input tokens and 60,000 output tokens every 60 seconds; 500 million input tokens and 5 million output tokens every 24 hours. Exceeding any limit returns HTTP 429. (Source: Hetzner Docs)

Q: How fast is the Hetzner Inference API?

A: Independent testing on July 23, 2026 reported a 153 ms median time-to-first-token and 224 output tokens per second for a single client. However, this is a one-time snapshot, not a guaranteed performance level. The experimental status means speeds may vary significantly under load. (Source: Sliplane.io)

Q: Can I use the Hetzner Inference API with AI coding agents like OpenCode?

A: Yes. Hetzner published a community tutorial showing how to configure OpenCode with the Inference API. Because the endpoint is OpenAI-compatible, any agent tool that supports custom API base URLs can use it. For security, run coding agents inside Docker Sandboxes (microVM-based isolation) rather than directly on your host machine. (Sources: Hetzner Docs, Docker Docs, Sandboxes)

Researched and drafted with AI agents; reviewed and fact-checked under human editorial oversight.