GridShare Docs: GPU cloud API, SDK and guides

REST API + Python SDK + CLI. Base URL: https://gridshare.in · All endpoints return JSON · TLS only

⚡ Quickstart — 60 seconds

1
Create an account & top up

Sign up at /app and add money by UPI or card. Current offers are on Pricing.

2
Get your API key

In the dashboard, open 🔑 API Keys in the left sidebar → Create key. Keys start with gs_live_ and never expire unless revoked.

3
Launch a GPU instance
cURL
Python
CLI
curl -X POST https://gridshare.in/v1/instances/ \ -H "Authorization: Bearer gs_live_YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "image": "gridshare/jupyter:latest", "min_vram_gb": 8, "exposed_ports": [8888] }' # Response: {"id":"...","status":"provisioning","ssh":{"host":"relay.gridshare.in","port":30042,...},...}
4
Stop when done — billing stops immediately
curl -X DELETE https://gridshare.in/v1/instances/inst_xxx \ -H "Authorization: Bearer gs_live_YOUR_KEY" # Billing stops within seconds of container termination

🔑 Authentication

All API endpoints require a bearer token. Pass your API key in the Authorization header:
Authorization: Bearer gs_live_your_api_key_here
You can have up to 10 active keys. Keys are shown only once at creation — store them securely. Revoke anytime.

Rate limits

Per client IP, sliding window:
EndpointLimitWindow
/v1/serverless/*300 reqper minute
/buyers/signup10 reqper minute
/buyers/login30 reqper minute
/webhooks/*60 reqper minute
All other endpoints600 reqper minute
Exceeding a limit returns 429 Too Many Requests — back off and retry after the window. Limits may tighten without notice for abusive traffic.

Rental limits

One rental can hold up to 200 open connections to public internet addresses at once. We check every 30 seconds. A rental above the limit is stopped, and the charge for the time it ran is not refunded. Your programs can read this from GET /v1/limits (no sign-in).
Every open port has a link: https://relay.gridshare.in/proxy/{instance_id}/{port}/. Apps outside the browser can sign in with your API key: send Authorization: Bearer gs_live_… (WebSockets too). When you resume a rental through the API, list every port you need in exposed_ports — ports you leave out are not opened.

🐍 Python SDK

Official Python client. Wraps the REST API with typed responses and retries.
# Install (the same wheel provides the `gridshare` CLI) pip install https://gridshare.in/dl/gridshare-0.2.3-py3-none-any.whl
import gridshare # Auth (or set the GRIDSHARE_TOKEN env var and skip this) gridshare.configure(api_key="gs_live_...") # — Instances — inst = gridshare.launch(template="pytorch-jupyter", gpu_vram=24) gridshare.list_instances() gridshare.get_instance(inst.id) gridshare.get_metrics(inst.id) gridshare.stop(inst.id) # — GPUs — gridshare.list_gpus(min_vram=24) gridshare.list_templates() # — Serverless (scale-to-zero endpoints) — gridshare.serverless.create(name="my-llama-3", image="yourname/your-llm-server:tag", env={"HF_MODEL": "meta-llama/Meta-Llama-3-8B"}) result = gridshare.serverless.run("my-llama-3", {"messages": [{"role": "user", "content": "Hello"}]}) # — Workspaces / agents whose saved files survive their machine dying — ws = gridshare.workspaces.run_agent(image="python:3.11-slim", start_command="python3 /workspace/agent.py") # — Secrets (encrypted env vars injected at boot) — gridshare.secrets.set("HF_TOKEN", "hf_abc123...") gridshare.secrets.list() # — SSH keys — gridshare.ssh_keys.add(label="MacBook", public_key="ssh-ed25519 AAAA...") # — Wallet — gridshare.balance()
Set the GRIDSHARE_TOKEN environment variable to avoid passing the key in code — the SDK reads it automatically. For explicit lifecycle control use gridshare.GridShareClient(api_key=...), which exposes the same methods. The SDK is synchronous; there is no async client yet.

💻 CLI Reference

# Install (installs the `gridshare` CLI and the Python SDK) pip install https://gridshare.in/dl/gridshare-0.2.3-py3-none-any.whl gridshare --help
# Auth gridshare signup # create an account gridshare login # saves to ~/.gridshare/config.json gridshare logout # Browse available GPUs gridshare gpus # available nodes (--min-vram, --city) gridshare templates # pre-built Docker templates # Instances gridshare launch # launch a GPU instance gridshare list # your instances gridshare status <id> gridshare stop <id> gridshare ssh <id> # interactive SSH session gridshare metrics <id> # live GPU metrics # Wallet & account gridshare balance gridshare student-verify # institutional email → student rate gridshare referral info # your referral link and status (offer: see /pricing)
Run gridshare <command> --help for the flags on any command. Serverless endpoints, secrets and SSH-key management are available through the Python SDK and the REST API (see the sections below) — they are not yet exposed as CLI subcommands.

⚡ Instances API

Create, list, stop GPU instances. Billing runs per second while the instance runs and stops at termination; on GridShare app templates the meter doesn't start until the app is actually ready (up to a 15-minute boot window).
POST/v1/instances/
Launch a new GPU instance.
# Request body { "image": "gridshare/jupyter:latest", # required — any template image or your own "label": "my-notebook", # optional: friendly name in the dashboard "gpu_count": 1, # 0-8 (0 = CPU-only) "min_vram_gb": 8, # optional: minimum GPU VRAM "disk_gb": 20, # workspace disk, 5-500 GB "exposed_ports": [8888, 7860], # ports proxied over HTTPS "env": {"MY_VAR": "value"}, # optional: additional env vars "use_secrets": true, # inject saved secrets at /run/gs_secrets/env "ssh_pubkey": "ssh-rsa AAAA..." # optional: passwordless SSH }
GET/v1/instances/
List all running instances for your account.
GET/v1/instances/{instance_id}
Get instance status, SSH details, GPU metrics, and billing info.
DELETE/v1/instances/{instance_id}
Stop and terminate an instance. Billing stops within seconds.
# Response example { "id": "0a1b2c3d-0000-4000-8000-000000000000", "status": "running", # provisioning|starting|running|stopped|error "image": "gridshare/jupyter:latest", "gpu_count": 1, "rate_per_hr_inr": 12.0, "total_cost_inr": 2.25, # total so far "ssh": { "host": "relay.gridshare.in", "port": 30042, "user": "root", "host_key_alias": "gridshare-0a1b2c3d", "command": "ssh -o HostKeyAlias=gridshare-0a1b2c3d -o CheckHostIP=no -p 30042 root@relay.gridshare.in" }, # null fields + "native_mac":true on Apple-silicon machines (no SSH — use the web apps) "port_map": {"8888": "https://relay.gridshare.in/proxy/0a1b2c3d-.../8888/"}, "created_at": "2026-08-28T17:44:00Z" }

Available templates & custom Docker

Template IDWhat you getUse case
pytorch-jupyterOpen your notebook and start training in 60 seconds.pytorch, jupyter, cuda
tensorflow-jupyterTensorFlow with GPU support, ready instantly.tensorflow, keras, jupyter
huggingfaceTransformers, Diffusers, Datasets — all pre-installed.huggingface, transformers, diffusers
pytorch-barePyTorch over SSH, no notebook. For a notebook pick PyTorch + Jupyter.pytorch, cuda, training
stable-diffusion-webuiThe simplest text-to-image app — type a prompt, get an image.stable-diffusion, automatic1111, image-gen
comfyuiNode-based workflow engine for Stable Diffusion.comfyui, stable-diffusion, workflow
invokeaiProfessional AI art tool with polished UI.invokeai, stable-diffusion, image-gen
ollamaRun Llama 3, Mistral, Gemma locally in minutes.ollama, llama3, mistral
vllmProduction-grade LLM serving — OpenAI API compatible.vllm, llm, inference
tgiHuggingFace's battle-tested LLM inference server.tgi, huggingface, llm
text-gen-webuiOobabooga — the most flexible LLM chat UI.oobabooga, text-gen-webui, llm
whisperOpenAI Whisper — GPU speech transcription in JupyterLab.whisper, asr, transcription
ubuntu-cudaClean slate. Install whatever you need.ubuntu, cuda, custom
ubuntu-cpuLightweight CPU shell. No GPU needed.ubuntu, cpu, shell
indic-asr-whisperTranscribe Hindi, Tamil, Telugu, Bengali & 20+ Indian languages.whisper, asr, hindi
indic-llm-finetuneLoRA-fine-tune an open Indian LLM on your own data.llm, fine-tune, lora
indic-doc-ocrExtract text from Indian documents & scripts.ocr, documents, indic
mlflowTrack every run, metric, and model — auto-starts on :5000.mlflow, mlops, experiment-tracking
code-serverYour VS Code, running on the rented GPU. Feels local.vscode, code-server, ide
llama-factoryFine-tune Llama/Qwen/Mistral from a web UI — no code.llama-factory, fine-tune, lora
label-studioAnnotate text, images, audio — your team's labeling workspace.label-studio, labeling, annotation
flowiseDrag-and-drop LLM apps and agents — no code.flowise, agents, no-code
customYour own Docker image from any registryany framework, any model

🔐 SSH Keys

Save your SSH public keys on your account once. When you launch a machine, choose one (in the app: 📋 Use a saved SSH key in the launch window; over the API: pass it as ssh_pubkey to POST /instances/) and it is added to ~/.ssh/authorized_keys on that machine.
POST/buyers/ssh-keys/
Add an SSH public key to your account. Max 10 keys.
{"label": "MacBook Pro", "public_key": "ssh-ed25519 AAAA..."}
GET/buyers/ssh-keys/
List all SSH keys on your account (public keys returned, not private).
DELETE/buyers/ssh-keys/{key_id}
Remove an SSH key. Does not affect running instances.
🔑 A machine launched without a key uses a generated password, shown in the dashboard under 🔐 SSH. Adding a key to your account also adds it to your machines that are already running, within a few seconds. Removing or rotating a key updates them too.

🔒 Secrets (Encrypted Env Vars)

Store sensitive values (HuggingFace tokens, API keys, database URLs) encrypted at rest. Inject them into instance containers without hardcoding in requests.
POST/buyers/secrets/
Create a secret. Value is encrypted before storage.
{"name": "HF_TOKEN", "value": "hf_aBcDe12345..."} # Name must be valid env var (A-Z, 0-9, underscore)
GET/buyers/secrets/
List secrets by name (values never returned after creation).
DELETE/buyers/secrets/{secret_id}
Delete a secret.
Enable secret injection when launching:
# With the SDK (the CLI has no --use-secrets flag yet) gridshare.launch(template="pytorch-jupyter", gpu_vram=24, use_secrets=True) # With API {"image": "gridshare/pytorch:latest", "use_secrets": true}

Where secrets appear inside the instance

Injected secrets are written to a file at /run/gs_secrets/env inside the container — they are not set as environment variables. The file contains plain KEY=VALUE lines:
# Shell — load all secrets into the current session source /run/gs_secrets/env # Python — parse the file directly secrets = dict( line.split("=", 1) for line in open("/run/gs_secrets/env").read().splitlines() if line and not line.startswith("#") ) hf_token = secrets["HF_TOKEN"]
⚠️ Secret values are shown once at creation. Store them separately. Decryption only happens at instance launch time, never returned via API.
⚠️ Honest security note: GridShare instances run on hardware owned by independent providers. File-based injection protects against casual inspection, but a determined host owner with root access can read container memory. Never inject production credentials into Community-tier instances — use scoped, revocable tokens (e.g. a read-only HuggingFace token) and rotate them after sensitive workloads.

🔮 Serverless API Beta

Deploy models as HTTP endpoints. Workers scale with your requests and scale to zero when idle. Use your own Docker image (see Your container below), or gridshare/serverless-echo:latest to check your setup. A fine-tune you pushed deploys with gridshare deploy.
BillingRateDetail
active computeShown in your consoleThe rate follows the GPU your endpoint runs on. Billed per 100 ms while a worker handles your request.
idleKeep-warm rate (shown in your console)After a request, a worker stays warm for the idle time you set (60 seconds by default), then scales to zero and costs ₹0. No monthly minimum, no reservation fee.
min_workers ≥ 1Keep-warm rate (shown in your console)Keeps a worker warm so the next call skips the cold start. Cold starts are never billed.
idle_timeout_sDefault 60 s (5 s to 30 min)How long a worker stays warm after its last request.
max_workersup to 20More workers start as the queue grows; each bills on its own.
POST/v1/serverless/endpoints/
Create a serverless endpoint.
{ "name": "my-llama-3-8b", "image": "yourname/your-llm-server:tag", "min_workers": 0, # 0 = scale to zero "max_workers": 5, "warmup_timeout_s": 300, # up to 900 — first download of a big image takes a while "env": {"HF_MODEL": "meta-llama/Meta-Llama-3-8B"} }
Your container: listen on port 8080, answer GET /health with 200 once the model is loaded, and handle POST /run — it receives {"input": {...}} and returns JSON.
POST/v1/serverless/{endpoint_id}/run
Invoke the endpoint. Blocks until result is ready (or use async variant).
{"input": {"prompt": "Explain transformers in Hindi", "max_tokens": 512}} # Response: {"id": "...", "status": "completed", "output": {...}, "compute_ms": 2100, "cost_inr": 0.026} # Waits up to 300 s. For longer jobs: POST /v1/serverless/{endpoint_id}/run-async, # then poll GET /v1/serverless/requests/{request_id}
GET/v1/serverless/endpoints/
List your serverless endpoints and their current worker counts.
DELETE/v1/serverless/endpoints/{endpoint_id}
Delete an endpoint. Running workers are stopped.

🔔 Webhooks

Get HTTP callbacks when instance/billing events happen. GridShare signs every request with HMAC-SHA256.
POST/webhooks/
Register a webhook URL and choose which events to subscribe to.
{ "url": "https://myserver.com/gridshare-hook", "label": "production", "events": ["instance.started", "instance.completed", "instance.migrated"] // omit "events" entirely to receive every event }
# Verify webhook signature (Python) import hashlib, hmac def verify_signature(secret: str, body: bytes, sig_header: str) -> bool: expected = "sha256=" + hmac.new( secret.encode(), body, hashlib.sha256 ).hexdigest() return hmac.compare_digest(expected, sig_header) # X-GridShare-Signature header contains: "sha256=<hex>"

Event types

EventTrigger
instance.startedContainer is running, SSH is ready
instance.completedInstance finished and was terminated normally
instance.failedInstance stopped because something went wrong (payload has the reason)
instance.preemption_warningProvider node is going offline — checkpoint/save now (work also auto-saves)
instance.migratedInstance auto-migrated to a new GPU after node failure (payload has new SSH details)
serverless.completedA serverless request finished successfully
serverless.failedA serverless request failed
workspace.createdWorkspace created
workspace.launchedWorkspace started on a GPU
workspace.pausedWorkspace paused — ₹0/hr, state kept
workspace.resumedWorkspace resumed on a GPU, state intact
workspace.updatedWorkspace settings changed
workspace.deletedWorkspace deleted
workspace.self_healedYour agent crashed and was restarted automatically
workspace.spend_limit_reachedWorkspace paused because it hit your spend limit
workspace.heal_circuit_brokenAuto-heal gave up — the workload keeps crashing
workspace.heal_no_capacityAuto-heal could not find a free GPU to move to

💰 Wallet & Billing

GET/buyers/me
Get account info including wallet balance, email, GSTIN, plan.
{"alert_threshold_inr": 200} # When balance < ₹200, you get alerted. Set to 0 to disable.
GET/buyers/wallet/history
Your 50 most recent wallet transactions, newest first. Each entry has id, created_at, amount_inr (negative for charges and refunds), type, description, method, status and notes (extra detail, not on every row). Instance usage is not in this list: GET /buyers/wallet/export?days=30 returns a CSV with both.
GET/invoices/monthly/{year}/{month}
Download a usage statement for a given month (YYYY-MM format) — a breakdown of wallet debits, not a tax invoice. GST is charged once at top-up; the tax invoice for each top-up is at /buyers/invoice/{payment_id} and is the document to claim input tax credit against.

🏢 Organizations (Team Accounts)

Share a single wallet across a team, with admin/member roles and one GST invoice. Up to 5 members free; Team plan 10, Business plan 50 (see Pricing).
POST/orgs/
Create an org. Converts your account to an org admin wallet.
POST/orgs/{org_id}/invite
Invite a member by email. They get a join link.
GET/orgs/{org_id}
List members, their roles, and spend this month.

Connecting to your machine with SSH

Every machine can be reached over SSH as root. In the app, open My Machines and click 🔐 SSH on a running machine: it shows the command, the user and the password, each with a copy button.
# the command shown under 🔐 SSH (your alias and port will differ) ssh -o HostKeyAlias=gridshare-0a1b2c3d -o CheckHostIP=no -p 30042 root@relay.gridshare.in
Copy the whole command, including both -o options. HostKeyAlias gives each machine its own entry in your computer's list of known machines, so a new machine on a port you used before is not mistaken for the old one. CheckHostIP=no skips only the extra check on our relay's address, which every machine shares; SSH still checks each machine's own key.
💡 No SSH needed? Click 🖥 Terminal on the machine for a terminal in your browser, already logged in. On notebook templates you can also open a terminal inside JupyterLab.

Logging in with the password (Windows CMD / PowerShell)

Nothing appears on screen while you type or paste a password; that is normal. In Windows Command Prompt, Ctrl+V does not paste into the password prompt: copy the password with its copy button, then right-click once inside the window and press Enter. A Permission denied message almost always means the password did not go in. The user is always root, not your email.

Checking the host key on first connect

The first time you connect, SSH asks you to confirm the machine's host key. Each machine has its own keys, so a new machine shows a new fingerprint. To check it, open 🖥 Terminal (it runs over HTTPS) and run the command below; the result should match what your SSH client shows.
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
If you see REMOTE HOST IDENTIFICATION HAS CHANGED, the command you used is probably an old one, or was typed without its -o options. The machine's key can also change if its software was rebuilt. Copy the current command from 🔐 SSH on the machine's card and use it as it is.

Logging in with an SSH key (no password)

1. Create a key on your computer (Windows, macOS and Linux) and press Enter through the questions:
ssh-keygen -t ed25519
2. Copy the one line in the public key file: C:\Users\<you>\.ssh\id_ed25519.pub on Windows, ~/.ssh/id_ed25519.pub on macOS and Linux. Never share the file without .pub; that one is private.
3. In the app, open Account → SSH Public Keys, paste it and click + Add SSH Key.
4. When you launch a machine, click 📋 Use a saved SSH key in the launch window. That machine then accepts your key, and you connect with the same ssh -o HostKeyAlias=… -o CheckHostIP=no -p … root@relay.gridshare.in command.
Saving a key also adds it to your machines that are already running, within a few seconds, so you can connect with it straight away.

Copying files and long jobs

# copy a file to the machine: same options and port as your SSH command (note: capital -P for scp) scp -o HostKeyAlias=gridshare-0a1b2c3d -o CheckHostIP=no -P 30042 ./train.py root@relay.gridshare.in:/workspace/ # run a long job so it keeps going if your connection drops tmux python /workspace/train.py # detach with Ctrl+B then D; reattach later with: tmux attach
Keep your work in /workspace: that folder is saved when the machine stops. You are billed per minute only while a machine runs, so stop it from My Machines when you are done. Need help? Write to support@gridshare.in (Mon–Sat, 11 AM – 8 PM IST).

How to run JupyterLab on a cloud GPU

Every instance launched with the pytorch-jupyter template (or another notebook template such as tensorflow-jupyter or huggingface) exposes JupyterLab in-browser.
# Launch Jupyter instance gridshare launch --template pytorch-jupyter --gpu-vram 16 # Get its URL (open it from the dashboard, or read it off status) gridshare status <id> # OR: open the machine's card at https://gridshare.in/app — the Jupyter # button opens https://relay.gridshare.in/proxy/<instance-id>/8888/
JupyterLab access is proxied through gridshare.in — no port forwarding needed. Works behind corporate firewalls.

How to run ComfyUI on a cloud GPU

ComfyUI starts on its own when you launch any of the templates below. Open it from your machine's card in the app — it opens in its own browser tab, with ComfyUI Manager already installed.
TemplateWhat it's forNotes
ComfyUIImage generation with the node editorSD 1.5 is included, so your first Queue renders right away (on RTX 50-series cards it downloads in the background on first start, ~2 GB). Add SDXL, Flux and others with ComfyUI Manager — see below.
LTX-Video 2BFast text-to-video, clips up to 768×512 at 24 fpsRuns on an 8 GB card. Downloads its model (11.5 GB) onto the machine on first start and adds a ready-made workflow.
Wan 2.1 VideoText-to-video (Wan 2.1 T2V-1.3B), up to 768×512Needs a 12 GB card. Downloads its model (9.8 GB) onto the machine on first start.
While a template's model is downloading on first start, ComfyUI is already usable. The meter runs during the download — about 4 minutes on a fast machine, up to 30 minutes on a slower connection.

Getting models onto your machine

⚠️ Don't use the "Download" button in ComfyUI's missing-models box. It saves the file to your own computer, not to the GPU machine, so ComfyUI still can't see it. Instead, use one of these:
1. ComfyUI Manager (easiest). Click Manager → Model Manager, search for the model and click Install. It downloads straight onto the machine, into the right folder.
2. Terminal. Open the terminal (or SSH) and download into the matching folder under /workspace/models:
# example: a checkpoint into the checkpoints folder cd /workspace/models/checkpoints wget -O my-model.safetensors "https://huggingface.co/<repo>/resolve/main/<file>.safetensors"
Model typeFolder
Checkpoints (SD 1.5, SDXL…)/workspace/models/checkpoints
LoRAs/workspace/models/loras
VAE/workspace/models/vae
ControlNet/workspace/models/controlnet
Upscalers/workspace/models/upscale_models
Text encoders / CLIP/workspace/models/text_encoders, /workspace/models/clip
Diffusion models / UNet (Flux, video)/workspace/models/diffusion_models, /workspace/models/unet
Embeddings/workspace/models/embeddings
ComfyUI picks up new files without a restart — refresh the page (or press R in ComfyUI) and they appear in the model dropdowns.

Making a video with LTX-Video

1. Launch the LTX-Video 2B (fast text-to-video) template. 2. Wait for the model download to finish — you can follow it in ltxv_download.log in your files. 3. Open the Workflows panel, choose "LTX-Video 2B — Text to Video", edit the prompt and press Queue.
Use our ready-made workflow rather than ComfyUI's built-in LTX template under Browse Templates — that one asks for different, larger model files (about 19 GB) that aren't on the machine, which is why it shows the missing-models box.
For Wan 2.1: after its download finishes (wan21_download.log), go to Workflow → Browse Templates → Video → "Wan 2.1 Text to Video" and press Queue.

Your images, videos and models after you stop

Everything ComfyUI generates is saved to /workspace/outputs, which is saved automatically. Use 📂 Browse on your machine's card to see and download your files.
Model files in /workspace/models are not part of the automatic save. Public models are simply downloaded again when you resume. To keep your own or private models between sessions, tick "Keep my large files in GridShare cloud storage" when you launch (₹6 per GB per month).
ComfyUI also runs on AMD Radeon machines — it installs itself on the first start (about 2 minutes) before the page opens.

What happens if a GPU fails: auto-save and auto-move

GridShare runs on consumer hardware owned by independent providers — nodes can and do go offline. The platform is built to make that survivable instead of pretending it never happens.

Auto-checkpointing

Every instance autosaves the files in /workspace automatically — there is nothing to enable:
TriggerBehaviour
intervalAutosave every ~30 seconds while running — files under /workspace, up to 20 GB. Skipped: venv, site-packages, node_modules, models, .cache, .git. To keep models and files over 256 MB too, switch on Keep my large files at launch (up to 500 GB, ₹6/GB per month). Shared network volumes are not offered yet.
shutdown_signalEvent-triggered save when the container receives a shutdown signal — provider stop or node going offline gracefully
Checkpoints are stored off-node, so they survive the death of the machine that produced them.

Auto-migration on node death

If the node running your instance stops responding, GridShare automatically:
1
Re-dispatches your workload

A replacement GPU with matching specs is found and your instance is re-created on it. If a checkpoint exists, work resumes from the last save.

2
Stops billing at the failure

You are not billed for any time after the machine stopped responding, and your job is moved at no cost — no support ticket needed.

3
Tells you where it went

Email and webhook (instance.migrated) — including the new SSH details, so scripts and humans both know where the instance went.

If no replacement GPU is available, the instance is stopped, billing ends when the machine stopped responding, and you're told — it never sits showing "running" against a dead node.
Subscribe to instance.preemption_warning and instance.migrated webhooks (see Webhooks) to checkpoint application state and re-point clients automatically.

⚖️ Acceptable Use

GridShare GPUs are for ML training, inference, rendering, and general compute. Cryptocurrency mining and other prohibited workloads are not allowed on any tier.
⚠️ Workloads are monitored using metadata only — never your code or data. Prohibited workloads are terminated without refund; repeat offences close the account. Full list: Acceptable Use Policy.