Track 12 · Advanced

12.2

EU-sovereign inference

GDPR-native, EU-hosted model access — before you reach for a US convenience API

10 lessons 2026-08-06 AI-generated

1Overview

When your own hardware isn't enough, an inference provider runs open-weight models for you and serves them over an API — but "the cloud" is not one jurisdiction. IONOS AI Model Hub, Scaleway and OVHcloud are EU companies running EU data centers: the same OpenAI-compatible base-URL swap as any US provider, but GDPR-native by default, with no US CLOUD Act exposure to explain to a data-protection officer. Mistral Medium is the EU-hosted flagship model to pick if you want quality, not just jurisdiction. Renting an EU GPU (e.g. via Hetzner) to self-host runs roughly a third of the equivalent hyperscaler price. Groq stays in this chapter for one reason: it is the fastest hosted option, US-based, and the explicit "convenience over data-residency" contrast — reach for it when speed matters more than where the data sits, never as the default for institutional data.

1.1Before you start

Local & Private Models— Reading Local & Private Models teaches you how AI can run entirely on your machine, preparing for EU-sovereign inference.

1.2After this chapter you can

→Reach EU-hosted, GDPR-native model inference over the same OpenAI-compatible API pattern

→Pick the right EU provider: IONOS for German data residency, Scaleway or OVHcloud for a buy-or-build choice, Mistral Medium for an EU flagship model

→Know why renting an EU GPU (e.g. via Hetzner) beats a hyperscaler on cost for the self-hosted path

→Recognize Groq/OpenRouter/Cerebras for what they are — the fastest, widest-choice options, and a deliberate residency trade-off, not the default

1.3What model should I choose for quality?

Mistral Medium is the flagship model hosted in the EU; it delivers strong quality while keeping all processing inside GDPR‑compliant data centres.

1.4When is a US provider worth using?

Choose a US‑hosted service like Groq or OpenRouter only when you need the fastest response times and widest model choice, accepting that data will reside outside the EU.

2Matrix 6 rows · 5 tools

ionos-ai-model-hub

scaleway

ovhcloud

mistral-medium

groq

EU-hosted infrastructure

yes

Vendor is an EU company

yes

OpenAI-compatible API

yes

partial

yes

Self-host option

yes (GPU rent)

yes (Mistral Open)

Speed (tokens/sec)

provider rate

500–800

Best for

German data residency

buy or build, one vendor

EU incumbent, audited track record

EU flagship-quality model

raw speed — convenience over residency

3Lessons 10

3.1 Obtain a Cerebras API key and run your first request

Cerebras gives you 1,000,000 tokens per day for free — no credit card needed. You will have a working API call in under 15 minutes.

Try

import openai
openai.api_key = "YOUR_CEREBRAS_API_KEY"
openai.base_url = "https://api.cerebras.ai/v1"
response = openai.ChatCompletion.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Write a haiku about AI"}]
)
print(response.choices[0].message.content)

Paste the code into a Python file or REPL after installing the openai package (pip install openai). Replace YOUR_CEREBRAS_API_KEY with the key you copied, then run; verify that a haiku prints—if you see an error about authentication, the key wasn’t set correctly.

Visit cloud.cerebras.ai and register using your university email, then confirm the verification link
In the dashboard open API Keys, click New API Key, copy the generated key and store it securely
Replace the OpenAI endpoint in your code with base_url="https://api.cerebras.ai/v1" and insert your copied key, then run the request
Observe the response printed to the console

You'll see A valid completion from the llama‑3.3‑70b model appears in your terminal
Takeaway A free Cerebras key gives immediate, high‑speed access to an EU‑hosted LLM without credit‑card details
Check After registering on cloud.cerebras.ai and inserting your key, what indicates that the llama‑3.3‑70b model request succeeded?

3.2 Make your first Groq API call

Groq gives you a free API key with no credit card — just an email or Google account. In this session you get the key, make one raw call, and feel the speed difference yourself.

Try

curl https://api.groq.com/openai/v1/chat/completions \
  -H 'Authorization: Bearer YOUR_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"model":"llama-3.1-8b-instant","messages":[{"role":"user","content":"Summarise the central dogma of molecular biology in 3 bullet points."}]}'

Paste the command into your terminal (or n8n HTTP Request node) after replacing YOUR_KEY with the API key you copied from the Groq console. Watch that the response returns within a second, confirming low latency.

Visit console.groq.com, click Sign in and authenticate with your university Google account
Select API Keys in the left sidebar, then choose Create API key and copy the generated key
Open a terminal (or n8n’s HTTP Request node) and execute a curl command, replacing YOUR_KEY with the copied value
Observe the JSON output returned by the request
Navigate to Usage → Rate limits in the console to view per‑model and organisational limits

You'll see A JSON response containing a ‘choices’ array with the generated answer appears instantly
Takeaway Groq provides an instant free key and sub‑second latency for EU‑hosted model queries
Check When you run the curl command with your Groq API key, what part of the JSON output confirms the model generated a response?

3.3 Call a free model using OpenRouter

OpenRouter is an API gateway: one API key and one OpenAI-compatible endpoint that reaches hundreds of models across every major provider (Claude, GPT, Gemini, Llama, Mistral, NVIDIA Nemotron, Gemma). You don't describe an app and watch it build — you send a chat request and a model answers. The fastest way to feel that is to call one of the many genuinely free models — their ids end in :free and cost $0 for both prompt and completion. No paid subscription is required to get a first reply.

Obtain a JSON reply from a free LLM by sending a request with your API key

Try

curl https://openrouter.ai/api/v1/chat/completions \
  -H 'Authorization: Bearer sk-testkey1234567890' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "google/gemma-4-31b-it:free",
    "messages": [{"role": "user", "content": "Summarise the role of p53 in tumour suppression in 3 sentences."}]
  }'

Paste the command into your terminal (or any shell window). After it runs, look for the choices[0].message.content field in the JSON output to see the model's reply.

Create an account at openrouter.ai and sign in
Generate an API key in the Keys section of your account settings and copy it securely
Select a free model by opening the catalogue at https://openrouter.ai/api/v1/models and noting an id that ends with :free
Send a request from a terminal using curl, inserting your API key and the chosen model id
Read the answer in the choices[0].message.content field of the returned JSON

You'll see A coherent JSON response appears, containing the answer in choices[0].message.content
Takeaway One OpenRouter API key gives immediate access to any :free model via a single endpoint and returns results as JSON
Check Which field in the OpenRouter JSON reply contains the actual answer text from the free model you called?

3.4 Run fast multi‑call agent loops on large models

Cerebras runs on wafer-scale silicon that delivers ~2,600 tok/s — the fastest public inference for large models anywhere. Combined with 1 M free tokens/day, it is the right choice for workflows that fire many short requests.

Do this first Obtain a Cerebras API key and run your first request

Execute dozens of short inference requests within Cerebras’ free daily token budget

Try

run a loop of 12 inference requests on Cerebras using the model llama-3.3-70b; each request should classify the following abstract: "[insert abstract text]" – keep each prompt under 500 tokens and submit them sequentially via the Cerebras web UI’s **New Inference** dialog.

Paste the entire command into the Cerebras Dashboard → Inference → New Inference field, then click Submit for each request. Watch the Tokens Used counter on the dashboard to confirm you stay well below the 1 M daily quota.

Open the Cerebras Dashboard in your browser
Select a model from the Model selector, e.g., llama‑3.3‑70b
Enter your prompt sequence and click Run to fire multiple classification or extraction calls
Refresh the Usage panel to verify token consumption remains under the daily limit

You'll see The Cerebras dashboard shows usage well below the 1 M token daily limit after a multi‑call loop
Takeaway Cerebras’ wafer‑scale chips enable rapid large‑model inference so tight agent loops stay within a generous free quota
Check How can you verify that multiple short inference calls stayed within Cerebras' 1 M daily token limit?

3.5 Transcribe a voice recording using Whisper

Groq hosts Whisper large-v3 alongside its text models, on the same fast hardware. A one-minute audio file comes back as text in roughly 2 seconds. This is the voice-to-lab-notes pattern used later in the n8n sessions.

Do this first Make your first Groq API call

Transcribe a voice recording with Whisper

Try

curl https://api.groq.com/openai/v1/audio/transcriptions \
  -H "Authorization: Bearer YOUR_KEY" \
  -F "file=@my_voice_note.mp3" \
  -F "model=whisper-large-v3"

Paste the command into a terminal window and hit Enter. In the JSON response, look for the text field – it contains the transcribed words from your audio file.

Record a 30‑second voice note on your phone or laptop and export it as .mp3 or .wav.
Run the curl command, replacing YOUR_KEY and the filename with your own values.
Read the transcript from the JSON response.
Drag the file onto the Audio tab in the Groq playground to repeat the transcription without using curl.

You'll see You get back a JSON object with a 'text' field containing your spoken words, accurately transcribed.
Takeaway Groq’s hosted whisper‑large‑v3 turns a one‑minute audio file into text in about two seconds, making voice‑to‑lab‑notes instantly practical
Check What element of the JSON response shows the transcribed text from your uploaded audio file?

3.6 Query an OpenRouter model in n8n

In this course, OpenRouter is the recommended LLM backend for n8n: because the endpoint is OpenAI-compatible, you don't need a special node or plugin. A single HTTP Request node — POST, one URL, one Authorization header — lets any workflow call any model. This lesson wires that node and gets a free model answering inside n8n.

Do this first Call a free model using OpenRouter

One HTTP Request node turns OpenRouter into your workflow's LLM

Try

{
  "model": "google/gemma-4-31b-it:free",
  "messages": [{"role": "user", "content": "Summarise the role of p53 in tumour suppression in 3 sentences."}]
}

Paste this JSON into the Body field of the HTTP Request node (set to raw JSON). After running the node, check the output under choices[0].message.content for the three‑sentence answer.

Open n8n and create (or open) a workflow. Add an HTTP Request node.
Set Method to POST and URL to https://openrouter.ai/api/v1/chat/completions.
Add two headers: Authorization: Bearer YOUR_KEY and Content-Type: application/json. Use your OpenRouter key from lesson 00 — do not hard‑code it where others can read it.
Set the Body (JSON) to: ``{ "model": "google/gemma-4-31b-it:free", "messages": [{"role": "user", "content": "Summarise the role of p53 in tumour suppression in 3 sentences."}] }``
Execute the node. A clean 3‑sentence answer comes back in the response body.

You'll see An n8n HTTP Request node returns a model answer from OpenRouter, with the reply visible under choices[0].message.content in the node output
Takeaway An n8n HTTP Request node can directly query any OpenRouter LLM via a single POST request and return the model’s answer within the workflow output
Check In n8n, where do you find the model's answer after executing the HTTP Request node configured for OpenRouter?

3.7 Check whether a prompt fits the free‑tier 8 192 token limit

Cerebras free tier caps context at 8,192 tokens — enough for short prompts and short documents, but a hard wall for long papers, large RAG chunks, or llama-4-scout's advertised extended context window.

Do this first Run fast multi‑call agent loops on large models

Identify if a request exceeds Cerebras' free‑tier context size and decide the next step

Try

Summarize this paragraph with Cerebras:

"AI has advanced dramatically, enabling breakthroughs in language models, vision, and reinforcement learning, leading to applications from healthcare to autonomous vehicles. Yet larger models raise concerns about cost, energy use, bias, and privacy, prompting research into efficient architectures and responsible AI practices."

Give a two‑sentence summary.

Enter the prompt in the Prompt box on Cerebras' inference page and press Submit. Ensure the output isn’t truncated—if it is, you’ve hit the 8K token limit.

Open the Cerebras dashboard in your browser
Click Settings → Contact and email support to request a higher context limit
Paste your text into the prompt field and watch for truncated output indicating the limit was hit
Visit the provider cheatsheet at /inference‑providers‑cheatsheet.html to compare Cerebras, Groq and OpenRouter limits

You'll see You can see whether your workflow stays within 8K tokens or requires a larger limit or another provider
Takeaway Cerebras' free tier only handles 8 192‑token contexts, so any prompt or document exceeding that silently truncates and requires a limit raise or another provider
Check What visual cue in the Cerebras dashboard tells you that your prompt exceeded the 8 192‑token free‑tier context limit?

3.8 Select the appropriate inference provider and avoid rate‑limit blocks

Groq's free tier has real constraints. Knowing them upfront saves you from hitting a wall mid-experiment. This card also shows you when Cerebras or OpenRouter is the better choice — the three providers share the same API shape, so switching is a one-line change.

Do this first Make your first Groq API call

Choose a provider that fits your quota needs and switch providers with minimal code changes

Trygroq chat

Run this command in a terminal where the groq CLI is set up with your personal key; observe if it returns a 429 Rate limit exceeded error, indicating you’ve reached the per‑model daily quota.

Open console.groq.com and generate your own free API key
Navigate to the Usage page and review the displayed rate‑limit table
Open the Inference Providers cheatsheet link and compare Groq, Cerebras and OpenRouter offerings
Replace the three parameters in your SDK call – set base_url, api_key and model – to point at Cerebras when a Groq limit is hit

You'll see Your console shows the current per‑model caps for your personal Groq key and your code runs after swapping three parameters to Cerebras
Takeaway Free tiers enforce organisation‑wide request limits and per‑model daily caps, so you monitor quotas and switch providers by changing only base URL, API key and model name
Check Which three parameters must you change to switch a running script from Groq to Cerebras when encountering rate‑limit blocks?

3.9 Compare responses from free and paid models by changing a single parameter

The single most useful habit OpenRouter unlocks is swapping models without touching anything else. The request body stays identical; only the model field changes. That makes it trivial to send one prompt to several models and see how they differ — and to feel the difference between a free model and a paid flagship on the same task.

Do this first Query an OpenRouter model in n8n

Run the same prompt on three different models by editing only the model name

Try

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/gemma-4-31b-it:free",
    "messages": [{"role": "user", "content": "Explain GDPR compliance in three concise bullet points."}]
  }'

Paste the command into your terminal and hit Enter. After the first response, edit only the value of the model field to the next model string and run again. Watch the output of the paid model for a note about token usage (cost) in the response metadata.

OpenRouter homepage analytics graphic showing two overlaid panels — a Throughput line chart and a Latency chart with three coloured trend lines — on a dark background. — OpenRouter surfaces throughput and latency per model, so when you switch the `model` parameter you can also see what you trade in speed and responsiveness — not just quality. Credit: openrouter.ai ↗

Copy a working request from an earlier lesson (curl, Python or n8n).
Execute the request with "model": "google/gemma-4-31b-it:free" and record the answer.
Replace the value of the model field with "nvidia/nemotron-3-ultra-550b-a55b:free", run the request again, and note the new answer.
Change the model field to "anthropic/claude-fable-5", execute the request a third time, and capture the paid‑model answer.
Place the three answers side by side and identify where they agree, where the paid model is sharper, and where a free model suffices.

You'll see Three distinct answers to one prompt, each generated by a different model, with at least one observable difference between the free and paid outputs
Takeaway Changing the model field lets you benchmark identical prompts across free and paid engines revealing performance gaps
Check What simple modification lets you compare the outputs of a free model and a paid model for the same prompt on OpenRouter?

3.10 Route requests cheaply and monitor costs

Once switching models is one parameter, a powerful pattern follows: route a request to a fast, cheap (or free) model first, and only fall back to an expensive flagship when the cheap model isn't good enough. OpenRouter also gives you one unified usage dashboard across every provider, so you can see cost per model in one place rather than logging into each provider separately.

Do this first Compare responses from free and paid models by changing a single parameter

Run cheap requests first, switch to a paid model when needed, and track spending

Try

In the OpenRouter chat window, send three messages to the free model `google/gemma-4-31b-it:free` asking:
1. "What are the key differences between GDPR and CCPA?"
2. "Summarize GDPR's main principles in bullet points."
3. "Give a short example of a compliant data‑processing notice."
Then send one message to the paid model `anthropic/claude-fable-5` asking: "Analyze this complex privacy policy and identify any clauses that might conflict with GDPR article 6."

Paste the whole block into the OpenRouter chat interface, selecting the appropriate model from the dropdown for each request. After sending, return to the Usage dashboard to verify the free calls show $0 and the paid call shows a token‑based charge.

Open usage dashboard on openrouter.ai and note current credits and recent spend
Send a batch of several requests to a :free model such as google/gemma-4-31b-it:free
Send one harder request to the paid model anthropic/claude-fable-5
Return to usage dashboard and locate the new entries, confirming free calls show $0 and the paid call shows a small per‑token charge
Define a fallback rule that decides which requests stay on a free model and which should be escalated to the paid model

You'll see The dashboard shows $0 for the free calls and a small charge for the paid call, plus your defined escalation rule
Takeaway Fallback routing lets you triage requests on free models and only spend on flagship models when quality requires it
Check How does the OpenRouter usage dashboard indicate that a request to a free model incurred no cost while a paid model did?

4You’ll know it worked 30 checkable outcomes in this chapter

✓The entire report appears within a few seconds without manual chunking
✓Five draft alternatives appear within 2 seconds after typing the prompt
✓Backlog items receive first-pass labels and the total bill is less than 10% of what a frontier model would cost
✓Script prints total seconds taken and calculated tokens-per-second close to 2,500-2,600
✓The terminal outputs a JSON object containing a "choices" array with the model's reply
✓You see a readable sentence or paragraph matching what was said in the audio
✓Requests succeed against the Cerebras endpoint with expected responses
✓Both runs produce correct answers corresponding to each distinct input

30 outcomes in all — one per recipe below.

5FAQ, Tips & How-to 80

one problem, one solution, one action

Internal tools & ops5

How-to

Cerebras Founder +1

Need a full document without breaking it up

Long single-shot outputs land almost as fast as short ones, so you stop breaking big requests into smaller chunks just to avoid staring at a slow stream.

~8 min · low code Lesson → AI-generated

How-to

Cerebras Finance +1

Want each team’s API use auto‑capped at the free daily limit

Spend per team is bounded by design, not by someone checking a dashboard at month-end — the free-tier limit does the enforcing.

~8 min · low code Lesson → AI-generated

How-to

Groq Operations

Internal knowledge‑base chatbot answers lagging

Adoption of the internal tool climbs because waiting no longer feels like a cost of using it.

~8 min · low code Lesson → AI-generated

How-to

Groq Founder +2

Voice assistant answers lag seconds

The conversation keeps pace with the user; no awkward multi-second pauses between question and answer.

~8 min · low code Lesson → AI-generated

Tip

OpenRouter Founder +1

Seamless responses during outages — automatic fallback to cheaper models

Your app keeps responding through provider outages and price spikes, staying inside budget without anyone touching the routing rules per incident.

Lesson → AI-generated

Research & data tools4

How-to

Cerebras Scientist

Abstracts summed up by sunrise

A literature batch that would tie up a GPU for hours is done by morning, for free.

~8 min · low code Lesson → AI-generated

How-to

Groq Small biz +1

Waiting for a morning ticket summary

The digest is ready before you'd normally still be waiting on it — nothing to schedule the night before, no overnight batch job to set up.

~8 min · low code Lesson → AI-generated

How-to

OpenRouter Scientist +1

Need cheap labels for a whole backlog

A whole backlog gets a first-pass label for a fraction of the price of a frontier model, with the option to escalate only the hard cases.

~8 min · low code Lesson → AI-generated

How-to

OpenRouter Scientist +2

You pick the best model for a task on evidence, not guesswork, and never re-wire your code to try another.

~8 min · low code Lesson → AI-generated

Content & marketing2

How-to

Groq Creator +1

Need fast draft options for a brainstorm

Picking from options feels like brainstorming live, not submitting a job and waiting.

~8 min · low code Lesson → AI-generated

How-to

OpenRouter Creator +1

Want to see which AI works best for your task

People get to compare frontier models for their own work, and you still only maintain one integration and one bill.

~8 min · low code Lesson → AI-generated

How-to

OpenRouter Everyone

Need an .env file with your API key and model IDs

Set up OpenRouter credentials so the proxy forwards requests

~5 min · no code Nick Saraev ↗ Summary → AI-generated

How-to

Cerebras Everyone

Want a free API key without a credit card

You can obtain a free Cerebras account without a credit card, giving you 1 000 000 tokens per day

Lesson → AI-generated

How-to

Cerebras Everyone

Need a way to prove each request is yours

Creating an API key gives you the secret needed to authenticate every request

Lesson → AI-generated

How-to

Cerebras Everyone

Need to point your OpenAI SDK at a different service

Replacing the default OpenAI endpoint with Cerebras' URL lets you use the same SDK code against Cerebras models

Lesson → AI-generated

How-to

Cerebras Everyone

Need a quick list of 10‑20 one‑sentence abstracts

A simple list of 10-20 one-sentence abstracts provides test data for the classifier script

Lesson → AI-generated

How-to

Cerebras Everyone

Need to tag a research abstract

Using the Cerebras endpoint with model "llama-3.3-70b" and a one-line system prompt returns a single label per abstract

Lesson → AI-generated

How-to

Cerebras Everyone

Timing the full batch run lets you compare actual throughput against the expected ~2,600 tok/s speed

Lesson → AI-generated

How-to

Cerebras Everyone

My prompt runs out of space

You can obtain a higher token limit for free by contacting Cerebras support, especially with an academic account

Lesson → AI-generated

How-to

OpenRouter Everyone

For RAG over full papers or any task needing more than 8 K tokens, use a provider without the free-tier cap

Lesson → AI-generated

How-to

Cerebras Everyone

You have a ready-made side-by-side table to decide which inference provider best fits each workload

Lesson → AI-generated

How-to

Cerebras Everyone

Need a reference for routing LLM tasks to providers with an 8 K cap

A reusable comment or note records which tasks go to which provider and reminds users of the 8 K Cerebras cap

Lesson → AI-generated

How-to

Groq Everyone

Can’t access the AI platform without a credit card

You can access Groq without a credit card by signing in with your university Google credentials

Lesson → AI-generated

How-to

Groq Everyone

Can’t authenticate requests

Generating an API key gives you a secret token that authenticates all future requests

Lesson → AI-generated

How-to

Groq Everyone

Need a quick AI summary from the terminal

A single cURL command can invoke Groq's Llama-3.1-8b-instant model and return a structured JSON answer

~5 min · no code Lesson → AI-generated

How-to

Groq Everyone

Groq enforces usage caps that are tied to your organization and model, not the number of API keys

Lesson → AI-generated

How-to

Groq Everyone

Need a short audio clip for transcription

You can quickly create a short audio file on any device to feed into Whisper

Lesson → AI-generated

How-to

Groq Everyone

Turn an audio file into text with a single curl command

Sending the audio to Groq's Whisper-large-v3 via a single curl command returns the transcript in seconds

Lesson → AI-generated

How-to

Groq Everyone

The response's `text` field gives you the exact spoken words, ready for further processing

Lesson → AI-generated

How-to

Groq Everyone

Need a quick text version of an audio file

You can drag-and-drop an audio file into the Groq console to get a transcript without writing curl commands

Lesson → AI-generated

How-to

Groq Everyone

Collect five PubMed abstracts into a Python list

Gathering five PubMed abstracts into a Python list lets you feed them to the Llama model in a loop

Lesson → AI-generated

How-to

Groq Everyone

Need to summarize many abstracts quickly

Looping over abstracts and calling `llama-3.3-70b-versatile` yields a concise summary for each in under 10 seconds total

Lesson → AI-generated

How-to

Groq Everyone

Timing the script demonstrates Groq's ability to handle multiple calls in a fraction of the time typical cloud APIs need

Lesson → AI-generated

How-to

Groq Everyone

Need a batch summarisation but don’t want to code in Python

Using n8n's Loop Over Items node together with an HTTP Request node replicates the same batch summarisation workflow visually

Lesson → AI-generated

How-to

Groq Everyone

Shared API key gets suspended

Using a personal API key avoids suspension of shared keys and guarantees free, instant experimentation

Lesson → AI-generated

How-to

Groq Everyone

Knowing the exact request limits prevents unexpected failures during experiments

Lesson → AI-generated

How-to

Groq Everyone

Each model has its own quota, so overall daily limits do not apply uniformly across models

Lesson → AI-generated

How-to

Groq Everyone

Need to switch AI back‑end

Moving from Groq to Cerebras requires only updating three settings, leaving the rest of your code untouched

~5 min · no code Lesson → AI-generated

How-to

Groq Everyone

The console shows current per-model caps so you can monitor your quota and avoid surprises

Lesson → AI-generated

How-to

OpenRouter Everyone

Want a free account

You can obtain an API key without any payment or credit card

Lesson → AI-generated

How-to

OpenRouter Everyone

Models whose IDs end with ":free" cost nothing for prompt and completion

Lesson → AI-generated

How-to

OpenRouter Everyone

Want an AI response from your terminal

A single HTTP POST to the OpenAI-compatible endpoint returns a JSON answer

Lesson → AI-generated

How-to

OpenRouter Everyone

The actual text answer lives in `choices[0].message.content` of the response

Lesson → AI-generated

How-to

OpenRouter Everyone

Want to ask a different research question

Changing only the `content` value lets you ask any domain-specific query

Lesson → AI-generated

How-to

n8n Everyone

Need to send data with POST to OpenRouter’s chat API

Setting POST and the correct endpoint directs the call to OpenRouter's chat API

Lesson → AI-generated

How-to

n8n Everyone

Need to hide your API key in a request

Providing a Bearer token authenticates your request without exposing the key in the workflow

Lesson → AI-generated

How-to

n8n Everyone

Need to pick a model and set your question for OpenRouter

The request payload tells OpenRouter which model to run and what message to answer

Lesson → AI-generated

How-to

n8n Everyone

Running an API call in a workflow

Running the configured HTTP Request returns a free-model response directly in the node output

Lesson → AI-generated

How-to

n8n Everyone

Can’t pass a generated value into my prompt

A preceding node can generate a value that becomes part of the HTTP request payload

Lesson → AI-generated

How-to

n8n Everyone

Need to use the AI’s reply in another step

You can route `choices[0].message.content` to another node for further processing, such as writing to a file or sending a message

Lesson → AI-generated

How-to

n8n Everyone

Running the workflow with multiple inputs confirms that dynamic prompting and response handling are robust

Lesson → AI-generated

How-to

OpenRouter Everyone

Seeing three answers side by side lets you spot concrete quality differences between free and paid models

Lesson → AI-generated

How-to

OpenRouter Everyone

You can monitor all model costs in one place without logging into each provider

Lesson → AI-generated

How-to

OpenRouter Everyone

A single difficult prompt on a paid model produces a measurable token cost

Lesson → AI-generated

How-to

OpenRouter Everyone

You can access Groq's API without providing a credit card

Groq docs — Billing FAQs ↗ AI-generated

How-to

Groq Everyone

App only talks to OpenAI

You can redirect tools built for OpenAI to Groq by changing the server address and API key

~5 min · no code Groq docs — OpenAI Compatibility ↗ AI-generated

How-to

Groq Everyone

Need to test accelerator models quickly

Free models have low per-minute and per-day request limits that reset daily; if you exceed them you get an error and must wait. The limits are intended for learning and experimentation, not for running a busy application. The exact current numbers are documented in OpenRouter's API rate-limit docs.

OpenRouter ↗ AI-generated

How-to

Groq Everyone

Waiting for slow AI replies

Calls Groq's inference endpoint with streaming enabled to receive token chunks at >500 tokens/sec, dramatically reducing response latency compared to traditional APIs.

Greg Kamradt ↗ Lesson → AI-generated

The same set on /recipes, filtered by tool and role.

6Videos 16

The Sovereign Cloud Exit: Migrating Off Hyperscalers with AI | Facets × OVHcloud

Facets Cloud ·~43 min ·Jun 2026 Intermediate

The business and regulatory context for EU data sovereignty — why organisations move off AWS/Azure/GCP at all.

Découvrez l'offre IA d'OVHcloud

OVHcloud ·~1 h ·Jun 2026 Intermediate

The official primer on where AI Endpoints sits in OVHcloud's stack; no English equivalent of this freshness exists yet.

OpenRouter getting started with free ai

Mike Møller Nielsen ·~10 min ·May 2026 Beginner

The hands-on counterpart to the explainer — after this you'll have OpenRouter actually returning responses in your code.

Master automation using n8n and IONOS Cloud nodes

IONOS UK ·~4 min ·Apr 2026 Intermediate

A drag-and-drop (no code) entry point to calling a sovereign German LLM API from n8n — the same n8n you already use in this course.

How To Get A Mistral API Key [2026 Guide]

AJ Tech Tutorials ·~2 min ·Apr 2026 Beginner

The fastest route from zero to your first call against Europe's flagship model provider.

Transform any n8n workflow with a sovereign agent

IONOS UK ·~6 min ·Mar 2026 Intermediate

Shows why you'd route inference through an EU provider instead of a US hyperscaler — in the practical n8n context, not as a policy lecture.

What is OpenRouter | All about OpenRouter in 10 minutes

codebasics ·~10 min ·Mar 2026 Beginner

The best 'what problem does this solve' intro from a well-known data/AI channel. Watch before wiring it into anything.

Groq LLM with Python | Ultra-Fast AI Inference Using Jupyter Notebook

ProGuruGyan ·~20 min ·Mar 2026 Intermediate

The 'is Groq actually fast?' video. Run the notebook yourself and see 200–500 tok/s in your own terminal — that's the moment Groq stops being marketing and becomes useful.

Claude Code + OpenRouter = Free UNLIMITED Coding (No RAM Needed)

Bart Slodyczka ·~10 min ·Mar 2026 Beginner

The most-asked-about OpenRouter use case right now. After this you can keep coding when your Anthropic rate limit hits, just by swapping the model.

Scaleway : du bare metal à l'inférence IA, un vrai hyperscaler | Cloud Native Days 2026

InformatiqueNews ·~17 min ·Feb 2026 Intermediate

The 'why a European hyperscaler for AI' narrative straight from Scaleway's CTO.

Mistral AI Le Chat Review 2026: Fastest ChatGPT Alternative Or Overhyped? (The Truth)

The Tutorial Lab ·~2 min ·Feb 2026 Intermediate

A balanced verdict on whether the EU champion holds up in daily use.

How to Get Groq API Key for Free (2026)

KodeBase ·~8 min ·Feb 2026 Beginner

Watch this five minutes before you start any Groq tutorial — it removes the only annoying step (account setup) so the actual learning starts immediately.

+ 4 more in the video library.

7FAQ 21

How do I get started with Cerebras?

Is there a free tier?

How fast is it, really?

What are the free-tier rate limits?

What would a researcher actually use Cerebras for?

How long of a document or conversation can I send to Groq?

Can I connect Groq to no-code automation tools?

What are the real practical limits of the free tier for everyday use?

What are the free tier rate limits — how many requests can I make?

Why is Groq so much faster than ChatGPT or other AI services?

What models are available on Groq? Which one should I use?

Can Groq transcribe audio or speech to text? Does it support Whisper?

What is OpenRouter and why would I use it?

Can I use OpenRouter with tools built for ChatGPT / the OpenAI API?

What happens if the AI model I'm using goes down?

How many models are available, and which providers are covered?

Can I use my own OpenAI or Anthropic API key instead of buying OpenRouter credits?

Does OpenRouter charge a markup over the model's official price?

How do I get an API key?

Are there free models, and which ones?

+ 1 more in the library.

8Glossary 49 terms

Show the 49 terms

Groq

.mp3: A common compressed audio file format; Groq's speech-to-text API accepts .mp3 files for transcription.
.wav: An uncompressed audio file format that stores raw sound data; Groq's speech-to-text API accepts .wav files for transcription.
whisper-large-v3: OpenAI's Whisper speech-recognition model (large version 3), hosted on Groq to convert spoken audio into text at high speed; supports formats including mp3, wav, flac, m4a, ogg, and webm.
pip install openai: A shell command that downloads and installs the official OpenAI Python library, which you can also use to talk to Groq because Groq's API follows the same format.
llama-3.3-70b-versatile: Meta's Llama 3.3 model with 70 billion parameters, available on Groq for general-purpose tasks; runs at ~280 tokens per second and supports a 131,072-token context window.
llama-3.1-8b-instant: Meta's smaller Llama 3.1 model with 8 billion parameters, available on Groq for fast, low-cost responses; runs at ~560 tokens per second with a 131,072-token context window.
base_url: A setting in the OpenAI Python client that tells it which server to send requests to; changing it to a Groq or other compatible endpoint lets you swap providers without rewriting your code.
api_key: A secret password-like string you get from an AI provider's dashboard; you pass it when connecting so the service knows who you are and can bill you correctly.
whisper-large-v3: The Groq-hosted OpenAI Whisper model used for speech-to-text; named in the model field of a transcription request and returns results almost instantly.
base_url: The openai SDK parameter pointed at Groq's endpoint so an OpenAI-compatible script runs on Groq by changing only this one value.
api_key: The credential, created in the Groq console, that authorises your requests; passed to the client so your script can call the API.
llama-3.3-70b-versatile: A larger, more capable Llama model on Groq, chosen in the model field when you need stronger reasoning rather than maximum speed.
llama-3.1-8b-instant: A small, fast Llama model on Groq suited to high-volume tasks where speed and a higher request cap matter more than reasoning depth.

OpenRouter

/api/v1/chat/completions: The OpenRouter API endpoint you send your message to — it receives your request, routes it to the chosen AI model, and returns the reply.
https://openrouter.ai/api/v1/models: A public OpenRouter URL that returns a JSON list of every available model, including its ID, pricing, context length, and supported features.
:free: A suffix you append to a model ID (e.g. meta-llama/llama-3.2-3b-instruct:free) to select the no-cost variant of that model; free variants have low daily rate limits and are intended for experimentation.
google/gemma-4-31b-it:free: An example OpenRouter model ID showing the standard format: provider name, a slash, the model name, and the :free variant suffix to use it at no cost.
anthropic/claude-fable-5: An OpenRouter model ID for Anthropic's Claude Fable 5, a high-capability model designed for long-running, autonomous coding and knowledge-work tasks.
choices[0].message.content: The path inside the API's JSON response where the model's actual text reply is stored — choices is an array, [0] picks the first (usually only) result, and .content holds the message text.
POST: An HTTP method that sends data to a server; when calling the OpenRouter API you POST your request (model choice, messages, settings) as a JSON body.
Authorization: Bearer YOUR_KEY: An HTTP request header that proves your identity to OpenRouter — replace YOUR_KEY with your actual API key so the server knows who is making the request.
Content-Type: application/json: An HTTP request header that tells the server your request body is formatted as JSON, which is required when calling the OpenRouter chat completions endpoint.
openai: The name of the official OpenAI Python package; because OpenRouter uses the same API format as OpenAI, you can install this package and point it at OpenRouter instead, saving you from learning a separate library.
pip install openai: A terminal command that downloads and installs the OpenAI Python package onto your computer so you can use it in your code.
model: A key in the JSON request body that tells OpenRouter which AI model to use for your request, specified as a provider/model-name string such as google/gemma-4-31b-it:free.

Cerebras

Cerebras Inference API: Cerebras's cloud service that lets you send text to an AI model and receive a response, accessed by sending HTTP requests to api.cerebras.ai/v1.
CEREBRAS_API_KEY: A secret password-like string you get from Cerebras that proves your identity every time your code calls the API.
gpt-oss-120b: OpenAI's 120-billion-parameter open-source model hosted on Cerebras hardware, capable of generating roughly 3,000 tokens per second.
zai-glm-4.7: A Mixture-of-Experts model from Z.ai with approximately 355 billion total parameters (32 billion active per token), available on Cerebras at around 1,000 tokens per second.
tokens per second: A measure of how fast the AI generates text — one token is roughly one word or word-piece, so 3,000 tokens/second means about 2,000 words generated every second.
Time to First Token: How long you wait from sending your request until the very first word of the answer appears; shorter is better for real-time, interactive applications.
streaming: A mode where the model sends its answer word-by-word as it is generated, so you can display text to the user progressively instead of waiting for the full response.
structured outputs: A feature that forces the model's response to match a JSON schema you define, so your code always receives data in a predictable, machine-readable shape.
JSON mode: A looser version of structured outputs that guarantees the response will be valid JSON but does not enforce a specific field structure.
reasoning_effort: An API parameter that tells the model how much thinking to perform before answering — options are low, medium, or high, trading speed for thoroughness.
reasoning tokens: Internal thinking text the model generates before its final answer; depending on the reasoning_format setting they may appear in the response or be hidden, but they always count toward your token usage.
prompt caching: A feature that reuses the processed results of repeated prompt prefixes — like a shared system prompt — so subsequent calls with the same opening are faster.
prompt_cache_key: An optional routing hint you attach to a request so that related requests (such as turns in the same conversation) are directed to the same cache, reducing latency.
predicted outputs: A feature where you supply the text you expect the model to produce; the model skips regenerating tokens that already match your prediction, speeding up the response.
Batch API: A service for submitting up to 50,000 AI requests at once as a JSONL file, letting them process in the background (guaranteed within 24 hours) and collecting all results when done.
JSONL: A plain-text file format where each line is a separate, valid JSON object — used to package many requests into one file for batch processing.
dedicated endpoint: A private, reserved slice of Cerebras infrastructure for your organisation alone, offering guaranteed throughput and advanced features like fine-tuning, custom model weights, and the Priority service tier.
shared endpoint: The standard public API where many customers share the same hardware; easier to get started with but performance may vary under high demand.
service tier: A setting on each API request that controls processing priority — Priority (dedicated endpoints only) is highest, Default is standard, Auto uses the highest available tier, and Flex is lowest-priority for non-urgent tasks.
OpenAI compatibility: Cerebras's API speaks the same language as OpenAI's API, so code written for OpenAI can be redirected to Cerebras by changing just the base URL and API key.
base_url: The web address your code sends requests to; for Cerebras it is https://api.cerebras.ai/v1, and changing this is how you switch from the OpenAI SDK to Cerebras.
RAG: Retrieval-Augmented Generation — a pattern where your application fetches relevant documents from a database and adds them to the prompt so the model can answer questions about your own data.
agentic workflow: A design where the AI autonomously takes multiple steps — calling tools, browsing data, making decisions — to complete a goal rather than answering a single question.
tool calling: A feature where you describe external functions (like a search engine or calculator) to the model, and it can request that your code run one of them mid-conversation to gather information.

💬 Discuss this chapter

Ask, share, or report — over on the Heidelberg AI community forum.

Ask a question Stuck on something? The community can help. Show what you built Share it — others can try it and cheer it on. Report a problem or idea Spotted a bug, or have an improvement?

1Overview

2Matrix 6 rows · 5 tools

3Lessons 10

3.1 Obtain a Cerebras API key and run your first request

3.2 Make your first Groq API call

3.3 Call a free model using OpenRouter

3.4 Run fast multi‑call agent loops on large models

3.5 Transcribe a voice recording using Whisper

3.6 Query an OpenRouter model in n8n

3.7 Check whether a prompt fits the free‑tier 8 192 token limit

3.8 Select the appropriate inference provider and avoid rate‑limit blocks

3.9 Compare responses from free and paid models by changing a single parameter

3.10 Route requests cheaply and monitor costs

4You’ll know it worked 30 checkable outcomes in this chapter

5FAQ, Tips & How-to 80

Internal tools & ops5

Get a complete multi‑section report in seconds

Distinct keys enforce it

Responses stay under one second

Get sub‑second replies

Seamless responses during outages — automatic fallback to cheaper models

Research & data tools4

Stays within the free‑tier daily token cap

Instant digest of top themes and urgent items

Get cent‑level first‑pass tags

How do different AI models compare on quality, speed and cost?

Content & marketing2

Get five alternatives in under 2 seconds

Pick Claude, GPT‑4 or an open model from a single dropdown

Get a ready‑to‑use .env file

1 000 000 tokens per day

Get an API key

Requests go to the new base URL

Ready batch classification test data

Get a single classification label

How fast is Cerebras inference in tokens per second?

Get a higher token limit from support

Which AI provider handles PDFs over 30 pages without truncation?

Which LLM inference provider fits my workload?

Comment block

Sign in using your university Google account

Get a one‑time API key

Get a JSON reply

What are Groq's per-model and org request limits?

30‑second .mp3 or .wav file

Get a JSON response containing the transcript

Where do I read the transcript in a Groq API response?

Drop it in and get an instant transcript

Ready for batch summarisation

One‑sentence summary per abstract

How fast can Groq summarize a batch of abstracts?

Visual loop workflow in n8n

You get a private key that always works

What are my exact Groq API rate limits?

What's the daily request cap for this Groq model?

Only three config changes needed

How do I see my current Groq usage against my quota?

Get an API key without paying

How do I know which OpenRouter model is free?

Get a JSON object with the text answer

Where is the actual answer text in the API response?

Reuse the same script

Request is correctly configured

Get a secure Authorization header

Get a ready‑to‑send JSON body

Get the model’s three‑sentence answer

It becomes part of the request payload

Forward answer to the next node

Does my workflow handle different inputs correctly?

How do free and paid OpenRouter models compare?

How do I check my OpenRouter balance and model costs?

How much does a complex prompt cost on a paid model?

Does the dashboard show free calls as $0 and paid correctly?

How do I get started with Cerebras?

Is there a free tier?

How fast is it, really?

What are the free-tier rate limits?

What would a researcher actually use Cerebras for?

Get a permanent free tier no card

Get a compatible endpoint you can point it at

3.7 Check whether a prompt fits the free‑tier 8 192 token limit

6Videos 16