Modal through Squiid

What Modal is

Modal turns a Python function into cloud infrastructure. You decorate a function with the image, the GPU type and the concurrency you want, and Modal builds the container, schedules it, scales it from zero and bills by the second it runs. It also provides volumes for persistent data, scheduled functions, queues, web endpoints and sandboxes for untrusted code, which together cover most of what a background worker fleet used to require. Images are defined in code and cached, so a change to one dependency rebuilds in seconds rather than re-uploading a whole container.

In an AI-coded product Modal is where the heavy work goes: running an open model on a GPU, batch-embedding a document corpus, transcoding files, nightly data jobs, and fine-tuning runs. It is also the escape hatch when a serverless host's ten second timeout becomes the limiting factor, because a Modal function can run for as long as the job needs and report back through a webhook or a queue. Concurrency limits and autoscaling are declared per function, which keeps a spike in traffic from turning into a spike in GPUs.

Why connect it through Squiid

GPU time is the fastest way to spend real money in a side project, so a ceiling matters. Squiid provisions the Modal workspace, holds the token and meters compute against your prepaid credits at Modal's published per-second rates, with spend shown per function so an accidental A100 loop is visible the same hour. Requests go to https://api.squiid.io/v1/modal/... with Authorization: Bearer $SQUIID_API_KEY, the Modal client works by pointing its base URL at the gateway (gateway convention), and the bill arrives with the rest of your stack.

• One account, one key, one bill, one dashboard. Modal sits beside every other service your project uses, on the same invoice and the same credit balance.
• Key custody. Squiid holds the Modal credentials. Your code carries SQUIID_API_KEY, so MODAL_TOKEN_ID, MODAL_TOKEN_SECRET, MODAL_ENVIRONMENT never land in a repository, a preview deployment or an agent’s context.
• Metering you can see. Every call is counted per service and per day, so you know what Modal costs before the month ends.
• Pause on zero. When prepaid credits run out the gateway stops authorizing usage instead of running up a bill you did not fund.
• One rotation. Rotating the Squiid key cuts off every agent, worker and deployment at once, with no provider key to hunt down.

What you get

• Serverless CPU and GPU functions with fast cold starts
• Volumes, queues, crons and web endpoints
• Long-running jobs beyond serverless timeouts
• Per-second compute metered per function
• Modal list pricing, no markup

How to connect Modal

One variable replaces the provider credentials this service would normally need. Requests go to the gateway and the official SDKs work by pointing their base URL at it (gateway convention).

# .env
# replaces MODAL_TOKEN_ID, MODAL_TOKEN_SECRET, MODAL_ENVIRONMENT
SQUIID_API_KEY=sq_live_xxxxxxxxxxxxxxxxxxxxxxxx

# every request: https://api.squiid.io/v1/modal/...
# header:       Authorization: Bearer $SQUIID_API_KEY

Pricing through Squiid

Modal charges per second of CPU, memory and GPU used while a function runs, at the provider's listed price. Squiid passes that through at par: one dollar of prepaid credit is one dollar of Modal usage, with no markup and no per-request margin.

Modal has no subscription attached on Squiid today. If a plan is required for a feature you need, it passes through at the provider’s listed price with no Squiid fee.

Squiid adds no markup to provider prices. There is a free plan at $0 a month with a 15% fee when you top up credits, Solo at $19.97 a month with a top-up fee that starts at 8% and falls to 3.5% as your spend grows, Team from $29.97 a seat a month with the same ladder one point lower, and Custom with a rate of 3% or less. Credits are prepaid, so Modal usage stops when the balance reaches zero rather than producing an invoice you did not fund. Auto top-up with a cap keeps production running without handing anyone an open-ended card.

If you leave

Export: images, templates and functions are rebuilt from your source in your own Modal account, and nothing persistent is left behind. Squiid never owns your code, your schema or your domain, and the gateway speaks Modal's own API, so the client change is a base URL. The handover page lists what happens for every provider in the catalogue.

Works with every coding agent

Modal through Squiid is just an HTTP call with a bearer token, so every agentic coding tool can use it with the single key already in your environment:

• Claude Code
• Cursor
• ChatGPT
• Codex
• Grok
• Gemini CLI
• GitHub Copilot
• Windsurf
• Perplexity
• Devin
• Replit
• v0
• Lovable
• Cline

Vibe coding a feature on Modal usually means asking for it in plain language and letting the agent write the integration. Because the key is Squiid’s rather than the provider’s, it can do that without ever holding a credential that could be leaked, logged or committed.