Run Ollama on a Cloud GPU with a Public HTTPS API in Two Minutes

Ollama is the easiest way to run open models, and a rented GPU is the easiest way to run Ollama when your laptop cannot. The annoying part has always been the last step: getting a URL you can call from somewhere else. This guide gets you from zero to curl https://…/api/chat in about two minutes, and explains what is happening so you can debug it when something is off.

Everything below was run on 6 September 2026 on cloudgpu.app. Times and prices are what we measured that day.

What you need

• A cloudgpu.app account. New accounts get $1.00 of trial credit, which is enough for this whole guide on a 4090.
• Nothing else. No CLI, no SSH key, no Docker.

Step 1: Deploy the Ollama template

Go to Deploy, choose Ollama, choose a card, click Deploy.

Which card:

Card	Price / hour	Good for
RTX 3090 (24 GB)	$0.21	7B to 13B models, cheapest way to try
RTX 4090 (24 GB)	$0.33	7B to 14B at full speed, 32B at 4-bit tightly
RTX 5090 (32 GB)	$0.59	32B at 4-bit with room for context, fastest FP8

The template ships with Ollama already running and a small model (qwen2.5:0.5b) pre-pulled so you can test the pipe before pulling something big.

Step 2: Wait about 100 seconds

The dashboard shows the instance as starting, then running. In our test:

• RTX 4090: running and reachable at 105 s.
• RTX 5090: running and reachable at 121 s.

When it flips to running you get two things on the instance row: an SSH command, and an API endpoint that looks like

https://5a18f8b218351513-i.cloudgpu.app

That endpoint is your Ollama server. It is only reachable while the instance runs, and the id is random, so keep it private.

Step 3: Call it

List models:

curl https://5a18f8b218351513-i.cloudgpu.app/api/tags

Chat (non-streaming):

curl https://5a18f8b218351513-i.cloudgpu.app/api/chat -d '{
  "model": "qwen2.5:0.5b",
  "stream": false,
  "messages": [{"role": "user", "content": "Say hello in five words."}]
}'

The first call after deploy takes a while. Ollama loads the model into VRAM on first use; for the 0.5B test model that was about 80 seconds in our run, and it scales with model size. Every call after that is fast. In our test a short chat completion round-tripped through Cloudflare in about one second.

If you want the first token immediately instead of waiting for the whole answer, stream:

curl https://5a18f8b218351513-i.cloudgpu.app/api/generate -d '{"model":"qwen2.5:0.5b","prompt":"hi","stream":true}'

Step 4: Use it from your tools

Ollama exposes an OpenAI-compatible endpoint at /v1, so anything that talks to OpenAI can talk to your box.

Python (openai SDK):

from openai import OpenAI

client = OpenAI(
    base_url="https://5a18f8b218351513-i.cloudgpu.app/v1",
    api_key="ollama",  # Ollama ignores the key but the SDK requires one
)
r = client.chat.completions.create(
    model="qwen2.5:0.5b",
    messages=[{"role": "user", "content": "Explain LoRA in one sentence."}],
)
print(r.choices[0].message.content)

Cursor / Cline / Continue: set the provider to OpenAI-compatible, base URL https://<your-id>-i.cloudgpu.app/v1, any non-empty API key, model name as listed by /api/tags.

Step 5: Pull the model you actually want

The test model is there to prove the pipe works. Pull a real one either from the dashboard (Pull model) or over SSH:

ssh root@<host> -p <port>
ollama pull qwen3:32b        # ~20 GB, fits a 5090 at 4-bit
ollama pull deepseek-r1:14b  # fits a 4090 comfortably

Download speed from the data centres we use is typically 100 to 200 MB/s, so a 20 GB model is about two to three minutes.

Step 6: Stop it

Click Destroy on the dashboard when you are done. Billing is per minute and the unused part of the pre-authorised hour goes back to your balance. There is no idle shutdown by default; if you want the box to live for a week, it can, as long as the balance covers it. You get emails six hours and one hour before the balance runs out.

What is actually happening

This part is for people who like to know why it works, and it is the reason the guide exists at all.

Most affordable GPU suppliers only expose one thing to the internet: JupyterLab on port 8888. Ollama’s port 11434 is unreachable from outside. Worse, the instances sit behind the supplier’s transparent HTTP proxy, so even outbound curl to arbitrary hosts on ports 80 and 443 fails or hangs.

When your instance boots, our backend logs in over SSH and installs a 16 MB reverse-tunnel client (frpc) that connects out on a high port to our server and forwards only the template’s API port. On our side, the tunnel is published as https://<id>-i.cloudgpu.app behind Cloudflare. Three things keep this from being a liability:

• The id is 16 random hex characters. Ollama has no authentication, so unguessable is the minimum.
• Our tunnel server asks our backend before accepting any tunnel, and only accepts the exact domain we registered for that instance. A token leaked from one instance cannot register a different name.
• Each tunnel is capped at 3 MB/s. Plenty for tokens, useless as a file mirror. Big downloads go through JupyterLab or SSH on the supplier’s own network.

JupyterLab, SSH and file transfers stay on the supplier’s URL. Only the API port rides our tunnel, which keeps our bandwidth bill boring and your model downloads fast.

Costs for this guide

Running through every step on an RTX 4090 took us 11 minutes, which is $0.06. On the 5090 it was 12 minutes for $0.12. The $1.00 trial credit covers it; after that, top up with USDT (TRC-20) or PayPal on the billing page.

Troubleshooting

• The API endpoint is missing on the instance row. The tunnel install is best-effort. If it failed, the instance still works over SSH; use ssh -L 11434:127.0.0.1:11434 root@<host> -p <port> and call http://localhost:11434. Tell us on the contact page with the instance id so we can look at the log.
• 504 on the first call. The model is still loading. Retry, or use streaming.
• 404 with a Cloudflare page. The instance has been destroyed or the tunnel dropped; check the dashboard.
• Slow first token on a big model. That is VRAM loading. A 20 GB model takes roughly 10 to 20 seconds on a 5090’s PCIe 5 link once the weights are on local disk.

Questions or a template you would like added? Contact us.