Experimental Free AI Inference API Launched by Hetzner

German hosting giant Hetzner has launched an experimental, zero-cost AI Inference API, offering developers a free gateway to run open-source large language models. This initiative, which began in July 2026, allows users to leverage powerful LLMs through an OpenAI-compatible endpoint without incurring any charges during the experimental phase. The service is hosted within Hetzner's EU data centers, addressing growing concerns around data sovereignty and privacy for European developers and businesses.

The current flagship model available through the API is Qwen/Qwen3.6-35B-A3B-FP8. Developed by Alibaba's Qwen team, this model is a Mixture-of-Experts (MoE) architecture. It boasts a total of 35 billion parameters, with approximately 3 billion active parameters per token processed. A significant feature is its expansive 262,144-token context window, enabling the model to process and retain information from much larger inputs compared to many contemporary LLMs. Furthermore, the model includes multimodal vision support, allowing it to interpret and respond to image inputs in addition to text.

To access the API, users need only a standard Hetzner account and a generated API token. Once authenticated, the endpoint can be called using any OpenAI-compatible SDK, streamlining integration into existing applications and workflows. This compatibility significantly lowers the barrier to entry for developers familiar with the OpenAI API, allowing them to switch to or experiment with Hetzner's offering with minimal code changes.

Hetzner cloud infrastructure overview showing EU data center locations

Understanding the Model and Its Capabilities

The choice of Qwen/Qwen3.6-35B-A3B-FP8 as the initial model is noteworthy. MoE architectures are designed for efficiency, allowing for a larger total parameter count while only activating a subset for each inference task. This approach can lead to faster processing and reduced computational cost for a given level of performance. The 35 billion total parameters suggest a model with substantial knowledge and reasoning capabilities, while the 3 billion active parameters per token indicate a lean inference process.

The extended context window of 262,144 tokens is a critical differentiator. This allows the API to handle lengthy documents, extensive conversation histories, or complex codebases in a single prompt. For applications requiring deep understanding of context, such as advanced summarization, detailed analysis of legal texts, or sophisticated chatbots that remember long interactions, this feature is invaluable. The multimodal capability further expands its utility, enabling use cases that combine text and visual information processing, like image captioning, visual question answering, or analyzing user interfaces.

Access and Usage: A Developer's Guide

Getting started with Hetzner's Free AI Inference API is designed for simplicity. The prerequisite is a Hetzner account. New users can sign up on the Hetzner website. Following account creation, users must navigate to their control panel to generate an API token. This token serves as the authentication credential for all API requests.

The API endpoint adheres to the OpenAI API specification. This means developers can typically use existing libraries and SDKs designed for OpenAI's models with minimal modification. For example, Python developers could use the openai library, simply changing the base URL to point to Hetzner's endpoint and using their generated token for authentication.

Here’s a conceptual example of how a Python call might look:


import openai

# Configure the API client with Hetzner's endpoint and your token
openai.api_base = "YOUR_HETZNER_API_ENDPOINT" # e.g., https://api.hetzner.cloud/v1/ai/inference
openai.api_key = "YOUR_HETZNER_API_TOKEN"

# Define the model to use (this would be the specific model identifier provided by Hetzner)
model_id = "Qwen/Qwen3.6-35B-A3B-FP8"

try:
    # Example: Chat completion request
    response = openai.ChatCompletion.create(
        model=model_id,
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "What is the capital of France?"}
        ],
        max_tokens=150
    )
    print(response.choices[0].message.content)

    # Example: Image analysis (if supported by the API and model)
    # This would require a different API call structure, potentially using 'vision' or similar parameters
    # and providing image data or URLs.

except Exception as e:
    print(f"An error occurred: {e}")

The rate limits are set at 3 million input tokens and 60,000 output tokens per 60 seconds. These limits are generous for experimental use and many production scenarios, but users should monitor their usage to avoid throttling.

Volatile Facts and Future Implications

It is crucial to understand that this offering is explicitly labeled as experimental. The provided facts, including pricing (currently zero), available models, and rate limits, are subject to change once the experimental phase concludes. Hetzner has not yet published its pricing structure for when the API moves beyond the experimental stage, nor has it committed to specific models or sustained service level agreements (SLAs).

The lack of an SLA means users should not rely on this free tier for mission-critical applications where uptime and guaranteed performance are essential. The