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
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:
| Endpoint | Limit | Window |
|---|---|---|
| /v1/serverless/* | 300 req | per minute |
| /buyers/signup | 10 req | per minute |
| /buyers/login | 30 req | per minute |
| /webhooks/* | 60 req | per minute |
| All other endpoints | 600 req | per 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).Port links from your own apps
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 ID | What you get | Use case |
|---|---|---|
| pytorch-jupyter | Open your notebook and start training in 60 seconds. | pytorch, jupyter, cuda |
| tensorflow-jupyter | TensorFlow with GPU support, ready instantly. | tensorflow, keras, jupyter |
| huggingface | Transformers, Diffusers, Datasets — all pre-installed. | huggingface, transformers, diffusers |
| pytorch-bare | PyTorch over SSH, no notebook. For a notebook pick PyTorch + Jupyter. | pytorch, cuda, training |
| stable-diffusion-webui | The simplest text-to-image app — type a prompt, get an image. | stable-diffusion, automatic1111, image-gen |
| comfyui | Node-based workflow engine for Stable Diffusion. | comfyui, stable-diffusion, workflow |
| invokeai | Professional AI art tool with polished UI. | invokeai, stable-diffusion, image-gen |
| ollama | Run Llama 3, Mistral, Gemma locally in minutes. | ollama, llama3, mistral |
| vllm | Production-grade LLM serving — OpenAI API compatible. | vllm, llm, inference |
| tgi | HuggingFace's battle-tested LLM inference server. | tgi, huggingface, llm |
| text-gen-webui | Oobabooga — the most flexible LLM chat UI. | oobabooga, text-gen-webui, llm |
| whisper | OpenAI Whisper — GPU speech transcription in JupyterLab. | whisper, asr, transcription |
| ubuntu-cuda | Clean slate. Install whatever you need. | ubuntu, cuda, custom |
| ubuntu-cpu | Lightweight CPU shell. No GPU needed. | ubuntu, cpu, shell |
| indic-asr-whisper | Transcribe Hindi, Tamil, Telugu, Bengali & 20+ Indian languages. | whisper, asr, hindi |
| indic-llm-finetune | LoRA-fine-tune an open Indian LLM on your own data. | llm, fine-tune, lora |
| indic-doc-ocr | Extract text from Indian documents & scripts. | ocr, documents, indic |
| mlflow | Track every run, metric, and model — auto-starts on :5000. | mlflow, mlops, experiment-tracking |
| code-server | Your VS Code, running on the rented GPU. Feels local. | vscode, code-server, ide |
| llama-factory | Fine-tune Llama/Qwen/Mistral from a web UI — no code. | llama-factory, fine-tune, lora |
| label-studio | Annotate text, images, audio — your team's labeling workspace. | label-studio, labeling, annotation |
| flowise | Drag-and-drop LLM apps and agents — no code. | flowise, agents, no-code |
| custom | Your own Docker image from any registry | any 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.| Billing | Rate | Detail |
|---|---|---|
| active compute | Shown in your console | The rate follows the GPU your endpoint runs on. Billed per 100 ms while a worker handles your request. |
| idle | Keep-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 ≥ 1 | Keep-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_s | Default 60 s (5 s to 30 min) | How long a worker stays warm after its last request. |
| max_workers | up to 20 | More 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
| Event | Trigger |
|---|---|
| instance.started | Container is running, SSH is ready |
| instance.completed | Instance finished and was terminated normally |
| instance.failed | Instance stopped because something went wrong (payload has the reason) |
| instance.preemption_warning | Provider node is going offline — checkpoint/save now (work also auto-saves) |
| instance.migrated | Instance auto-migrated to a new GPU after node failure (payload has new SSH details) |
| serverless.completed | A serverless request finished successfully |
| serverless.failed | A serverless request failed |
| workspace.created | Workspace created |
| workspace.launched | Workspace started on a GPU |
| workspace.paused | Workspace paused — ₹0/hr, state kept |
| workspace.resumed | Workspace resumed on a GPU, state intact |
| workspace.updated | Workspace settings changed |
| workspace.deleted | Workspace deleted |
| workspace.self_healed | Your agent crashed and was restarted automatically |
| workspace.spend_limit_reached | Workspace paused because it hit your spend limit |
| workspace.heal_circuit_broken | Auto-heal gave up — the workload keeps crashing |
| workspace.heal_no_capacity | Auto-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:
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
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.
| Template | What it's for | Notes |
|---|---|---|
| ComfyUI | Image generation with the node editor | SD 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 2B | Fast text-to-video, clips up to 768×512 at 24 fps | Runs 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 Video | Text-to-video (Wan 2.1 T2V-1.3B), up to 768×512 | Needs 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 type | Folder |
|---|---|
| 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:| Trigger | Behaviour |
|---|---|
| interval | Autosave 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_signal | Event-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.