With GPU Flow you use professional graphics cards (GPUs) hosted in Spain over the internet, with no hardware to buy. Three products run on them: Token Factory, an API for calling AI models; the SSH Sandboxes, Linux machines where you do the coding; and the dedicated GPU, a full B200 (or a slice) reserved just for you. Every chapter starts from scratch; no prior knowledge required.
GPU Flow has three products on the same platform. Before getting into detail, here's the essential difference between them and when to use each.
0.1Who is it for?
You don't need to be an infrastructure expert. GPU Flow is made both for people who code and for those who just need results:
Developer
Builds a product
Wants to add AI to their app without managing servers. Changes one URL in their code and starts calling the model. → Token Factory.
Data science
Trains models
Needs a powerful, dedicated GPU to train, fine-tune or run heavy sustained workloads. → Dedicated GPU.
Business
Decides & complies
Cares about cost, euro invoices and GDPR-compliant data that never leaves the EU. All three products deliver on that.
Think of it this way. A GPU is like an industrial kitchen: buying and maintaining one is hugely expensive and only worth it if you cook non-stop. GPU Flow rents it to you by the hour (the dedicated GPU) or serves you ready-made dishes through its API (Token Factory), paying only for what you consume. The Sandbox is your workstation wired into that kitchen.
0.2How it all fits together
All three products run on the same sovereign infrastructure in Spain:
Token Factory
API: your app calls over HTTP
Sandboxes
SSH: your editor on the cluster
Dedicated GPU
B200 GPU reserved for you
GPU Flow platform
The dashboard where you configure and launch each product
Infrastructure
NVIDIA B200RDMADDN EXAScalerEspaña · UE
0.3Which one do I pick?
If you want to…
Token Factory
Sandboxes
Dedicated GPU
Call a model from your app
✓
·
·
A Linux SSH box to code on
·
✓
·
A whole (or fractional) dedicated GPU
·
·
✓
Large-scale training or fine-tuning
·
·
✓
Pay per token consumed
✓
·
·
Pay per active hour
·
✓
✓
Data 100% in the EU
✓
✓
✓
Combine them? It's common: you develop in a Sandbox, train on a dedicated GPU and serve the model in production via Token Factory. They're also connected under the hood: your Sandbox's code assistants (Claude Code, Open Code) can run on Token Factory models, and those tokens are billed as part of the Sandbox's own usage, not as a separate service.
1
Chapter 1 · Token Factory
One API. SDKs you already know.
Token Factory serves open-source models from our infrastructure in Spain through an API compatible with OpenAI and Anthropic. An SDK is the library you use in your language (Python, JavaScript, etc.) to talk to an API; if you already use OpenAI or Anthropic, you just change the base URL and your key, and the rest of your code stays the same.
In a nutshell
An API to use AI models over the internet, with nothing to install or host. You pay only for what you consume, measured in tokens.
1.1What is an inference API?
"Inference" is simply the moment an already-trained AI model answers a question. An "API" is the door through which your software talks to other software. Put together: your app sends a request with your text, our server passes it to the model running on a GPU and returns the answer, usually in under a second and, if you want, word by word (streaming).
The good part: because we speak the same "language" as OpenAI and Anthropic, you don't rewrite your code. You change the address it points to and that's it.
The round-trip of one request:
1The request travels from your app to the model
your app
sends your text and key
API GPU Flow
api.gpuflow.ai validates and routes
model on GPU
generates the answer · Spain
2The answer makes the reverse trip back to your app
Answer the model returns the generated text to your app, word by word if you enable streaming.
And "tokens"? The model doesn't read letters or whole words but chunks called tokens (a short word is usually 1 token; a long one, 2-3). You count input tokens (what you send) and output tokens (what it answers). That's how price is computed:
Example sentence → "GPU Flow serves AI models from Spain"
GpuFlowservesAImodelsfromSpain
tokens ≈ 9input price (DeepSeek V4 Pro) 0,42 €/Mcost of this sentence ≈ 0,0000038 €
Think of it this way. Tokens are like a taxi meter: you don't pay per "trip", you pay for the actual distance travelled. Short prompts cost fractions of a cent; spend only adds up at high volume.
Three things worth understanding about API consumption:
1Input and output are billed separately. Output usually costs more per token: generating text is more expensive than reading it.
2Each call is independent. The model remembers nothing between requests. To hold a conversation you resend the history on every call, and that history also counts as input tokens, so long conversations consume more.
3Streaming doesn't change the price. You pay the same tokens; you just see the answer appear sooner, word by word.
Speed. Because the models run on our NVIDIA B200 GPU cluster in Spain, answers start arriving within milliseconds and at a high tokens-per-second rate, with none of the latency of crossing the Atlantic.
1.2Get started in 3 minutes
1Top up credit
Pick an amount (from €25) and pay by card, Apple Pay or Google Pay. Credit loads instantly. The more you top up, the more bonus you get.
2Get your API key
After payment you get an email to set your password. Your key appears in the dashboard, prefixed with gpf-. Copy it; it's shown only once.
3Point your SDK
Change the base_url to api.gpuflow.ai/v1, paste your key and pick a model from the catalogue. You're now running inference.
1.3Your first call
Using the OpenAI Python SDK. Only two lines change: base_url and api_key.
python · openai
from openai import OpenAI
client = OpenAI(
base_url="https://api.gpuflow.ai/v1",
api_key="gpf-...",
)
response = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[{"role": "user", "content": "Hola, mundo"}],
stream=True,
)
for chunk in response:
print(chunk.choices[0].delta.content or "", end="")
Using the Anthropic SDK? That works too: point to api.gpuflow.ai and use the /v1/messages endpoint. Compatible with SSE streaming and function calling where the model allows it.
1.4Main endpoints
POST/v1/chat/completionsChat · OpenAI format
POST/v1/messagesChat · Anthropic format
GET/v1/modelsList of available models
Base URL: https://api.gpuflow.ai/v1 · authenticate with Authorization: Bearer gpf-…
1.5Model catalogue
Models served today in Spain. Prices in EUR per million tokens, VAT included, split into input (your prompt) and output (the response). The ★ marks featured models.
ANot sure which? Start with a ★ featured model (DeepSeek V4 Pro): a good balance of quality and price for most tasks.
BHigh volume or simple replies: pick a small model (Qwen3.5 9B, Gemma 4 E2B): cheaper and almost instant.
CReasoning or complex code: use the larger ones (DeepSeek V4 Pro, GLM 5.2 FP8). They cost more per token but get it right more often.
Model
Capabilities
Input · €/M
Output · €/M
DeepSeek V4 Pro★
ChatReasoningCodingTools
0,42 €
0,85 €
GLM 5.2 FP8★
ChatCodingTools
1,00 €
3,00 €
DeepSeek V4 Flash
ChatReasoningTools
0,11 €
0,22 €
Qwen3.6 27B
ChatReasoningTools
0,10 €
0,30 €
Qwen3 14B
ChatReasoningTools
0,10 €
0,24 €
Qwen3.5 9B
ChatReasoningTools
0,03 €
0,15 €
Gemma 4 E4B
ChatReasoningTools
0,10 €
0,28 €
Gemma 4 E2B
ChatReasoningTools
0,05 €
0,24 €
Need another model? If it fits the GPU, we'll deploy it; write to [email protected].
1.6Credit & billing
Prepaid model: top up whenever you like and it's consumed by real usage (tokens). Each top-up comes with a Spanish VAT invoice.
25 €
25 €
no bonus
50 €
60 €
+10 € · +20%
100 €
120 €
+20 € · +20%
Best value
500 €
650 €
+150 € · +30%
The amount you pay is shown on top; the credit you receive includes the bonus. Higher volume or B2B usage? Enterprise tiers exist; just ask.
Cost example. Processing 500,000 input tokens and generating 200,000 output tokens with DeepSeek V4 Pro costs: (0.5 × €0.42) + (0.2 × €0.85) = €0.38. No per-request fee, no minimums.
2
Chapter 2 · Sandboxes
Your Linux machine, over SSH.
A Sandbox is a Linux container with dedicated CPU, RAM and disk. You connect over SSH with your own editor or terminal, your files live on a persistent volume, and AI power comes from Token Factory over the internal network. You only pay for the hours the Sandbox is actually active.
In a nutshell
A Sandbox is a remote computer you connect to over the internet as if it were your own, with dedicated CPU, RAM and disk. You pick the resources you need and, for AI tasks, call Token Factory models over the internal network. When you are not using it, it goes to sleep on its own and stops charging you.
2.1What is a Sandbox?
You connect to it over SSH, a secure connection, with your own editor or terminal, and install whatever you need. It's ideal for developing, running notebooks and wiring your agents to inference, with no infrastructure to set up.
The key to not overspending is understanding its three states and what's billed in each:
Active
On and working. You connect and run your processes.
bills compute + disk
Idle 30 min
No activity from you. After 30 min it auto-suspends (or you pause it).
idle countdown
Suspended
Asleep. Back in 5-8 s on reconnect, everything intact.
bills disk only
2.2Why on our cluster
A GPU Flow Sandbox isn't just any remote machine: it runs on the same sovereign cluster as the rest of the platform, and that's where its advantages come from.
Inference next door
Dedicated compute and a low-latency internal RDMA link to Token Factory: your agents call the models without going out to the internet, and with none of the trans-Atlantic latency.
High-speed data
DDN EXAScaler parallel storage to move large datasets and checkpoints without waiting. And on reconnect your Sandbox resumes in 5-8 s, with no long boots.
Privacy by design
Your code and data live in Spain, on dedicated hardware (not shared with other customers), and never leave the European Union. GDPR compliance with no international transfers.
Clear costs, in euros
You pay only for active hours (when suspended, compute stops billing) and always see the estimated cost before confirming. Spanish VAT invoice, no currency conversion.
The container you work in: dedicated CPU, RAM and disk. It can be active, paused or starting.
Persistent volume
Your /workspace disk. It survives suspensions and even deleting the Sandbox. Reuse it in a new Sandbox whenever you want.
Auto-suspend
After 30 min idle the Sandbox sleeps and stops charging compute. It's back in 5-8 s on reconnect. You can set it to manual.
Active hours
The wall-clock time the Sandbox is on. That’s what you pay for compute. Disk is always billed.
2.4Create a Sandbox, step by step
1Identity
Name your Sandbox and pick the base image (the system you boot from).
2Persistent volume
Create a new one or reuse a free one. Choose the disk (10–500 GB). Leave it unlabelled and we name it workspace-1, -2…
3Plan & resources
Pick your plan (Starter, Pro or Team): each sets vCPU, RAM and disk. AI power comes from Token Factory — no GPU in the Sandbox itself.
4Auto-suspend
Set the idle time before sleeping, or pick "manual" for long jobs you don’t want interrupted.
5Code assistants
Optional: Claude Code (with your Anthropic account or GLM 5.2 FP8 tokens) and/or Open Code. One, both or none.
6SSH key & summary
Paste your public SSH key, review the cost summary and confirm. The Sandbox provisions in seconds.
2.5Connecting over SSH
SSH is the standard way to log into a remote computer securely. Instead of a username and password it uses a key pair: two files that only work together. Understanding this pair is the only "new" thing you need:
shareable
Public key
id_ed25519.pub
It's like a lock: you paste it into the GPU Flow dashboard. Anyone can see it; on its own it opens nothing.
never share
Private key
id_ed25519
It’s your physical key: it stays on your machine. If someone gets it, they can impersonate you. Never upload it anywhere.
Step 1: generate your key (if you don't have one). The file without .pub is your private key: never share it. You only paste the .pub into the dashboard.
Windows · PowerShell
# 1 · create the keys folder
New-Item -ItemType Directory -Force -Path "$HOME\.ssh" | Out-Null
# 2 · generate your key (Enter for no passphrase)
ssh-keygen -t ed25519 -C "gpuflow"
# 3 · copy & paste this to get your key and view it again later
Get-Content "$HOME\.ssh\id_ed25519.pub"
macOS · Linux
# 1 · create the keys folder
mkdir -p ~/.ssh && chmod 700 ~/.ssh
# 2 · generate your key (Enter for no passphrase)
ssh-keygen -t ed25519 -C "gpuflow"
# 3 · copy & paste this to get your key and view it again later
cat ~/.ssh/id_ed25519.pub
Paste the line starting with ssh-ed25519 into the wizard's public-key field.
Step 2: connect. You go through our public bastion, no VPN needed. The bastion checks your key's fingerprint and routes you to your Sandbox.
your machine
SSH client + private key
bastion
ssh.gpuflow.ai verifies your fingerprint
your Sandbox
devpod-<nombre> compute + /workspace
bash · ssh
# connect via the bastion (no VPN) · replace <tu-entorno> with your Sandbox name
ssh -J ssh.gpuflow.ai developer@devpod-<tu-entorno>
Verify the fingerprint. The first time, your SSH client shows the host fingerprint. Compare it with the one on the Sandbox's detail page in your dashboard before accepting. You'll find the exact command, pre-filled with your Sandbox name, on that same page.
2.6Persistent volume lifecycle
This is the most surprising and most useful part: deleting the Sandbox does not delete your data. The volume survives and you reuse it whenever you want.
01
Create
Creating the Sandbox creates its volume.
02
Work
Your files live in /workspace.
03
Pause
Disk survives intact; compute stops billing.
04
Delete Sandbox
The Sandbox goes; the volume stays free and reusable.
05
Reuse / delete
Attach it to a new Sandbox, or delete it yourself separately.
A volume is billed as long as it exists, even if no Sandbox uses it. When you no longer need the data, delete it from the Persistent volumes section of the dashboard to stop paying for it.
2.7How it's billed
Three simple rules, and you'll always see the estimated cost before confirming:
Compute
Active hours only. When suspended, it stops charging.
Disk
Always billed, whether the Sandbox is active or paused.
AI tokens
If you use assistants with our tokens, by real usage.
3
Chapter 3 · Dedicated GPU
A B200 reserved just for you.
A dedicated GPU is an NVIDIA B200 (full or in MIG fractions) reserved exclusively for your workload, with stable performance and hardware isolation. Unlike a Sandbox, it is not shared or reassigned: it is yours while reserved. Today it is provisioned manually — you pick the configuration and we contact you to set it up.
In a nutshell
An NVIDIA B200 GPU reserved just for you, hardware-isolated, for continuous workloads that need guaranteed capacity. You pick the configuration on the site and we contact you to provision it.
3.1What is a dedicated GPU?
It is a GPU reserved exclusively for your project, as opposed to a Sandbox where the accelerator is assigned on demand. It is the right fit when you have a continuous workload (long training, production inference) and want stable, predictable performance.
3.2Configurations
We offer the full B200 (180 GB) and MIG fractions (mutually isolated slices of a B200) for smaller workloads. Exact configurations and prices are on the pricing page; product detail on the dedicated GPU page.
3.3How to request it
In the dedicated GPU configurator you pick the GPU model; the rest of the options are fixed for now. On submit, we ask for your details and contact you to reserve and set up your node. Once active, you connect over SSH just like a Sandbox (same bastion, same public key).
3.4How it's billed
As reserved capacity, pricing is tailored to the configuration and reservation period — we confirm it during contact. Reference rates (full B200 and MIG fractions, hourly or reserved) are on the pricing page.
3
Chapter 3 · Glossary
The key terms, in plain language.
If you've hit a term and weren't sure what it meant, here it is explained without jargon.
3.1General concepts
GPU
Graphics card. A chip built to do huge numbers of calculations at once; it's what makes AI fast.
Inference
The moment a trained model answers a question. The opposite of "training".
LLM
"Large Language Model": an AI model that understands and generates text (like the one behind a chat).
Token
The smallest chunk of text the model counts. A short word ≈ 1 token. It's the unit price is measured in.
API
The "door" through which one program talks to another over the internet.
SDK
A toolkit (library) for your programming language that makes using an API easier.
Streaming
Receiving the answer bit by bit, word by word, instead of waiting for the whole thing.
base_url
The address your code sends requests to. Changing it is all you need to use GPU Flow.
3.2Sandboxes & infrastructure
SSH
A secure way to connect to and command a remote computer from your own.
Public / private key
The SSH file pair: the public one is the lock (shared), the private one is the key (never shared).
Bastion
A secure middle server you pass through to reach your Sandbox, no VPN needed.
Persistent volume
The disk (/workspace) where your files live. It survives even if you delete the Sandbox.
Auto-suspend
The Sandbox sleeping by itself after a while idle to stop charging you compute.
vCPU / RAM / vRAM
Processor, system memory and graphics-card memory, respectively.
RGPD / GDPR
The European data-protection regulation. GPU Flow complies by keeping everything in the EU.