# Cerebrium vs Cloud Run GPUs (slim)

> Cloud Run GPUs scores 68.4 (B) to Cerebrium's 52.5 (D) for gpu compute. Prices, MCP, x402, uptime and agent notes side by side.

- Full: https://www.anchorterminal.com/compare/cerebrium-vs-cloud-run-gpus.md (~5,250 tokens) · this version ~3,130 tokens · JSON https://www.anchorterminal.com/compare/cerebrium-vs-cloud-run-gpus.json · canonical https://www.anchorterminal.com/compare/cerebrium-vs-cloud-run-gpus
- Index: https://www.anchorterminal.com/llms.txt · API: https://www.anchorterminal.com/api/v1/index.json · MCP: https://www.anchorterminal.com/mcp · Updated: 2026-11-07
- Licence: CC BY 4.0, credit Anchor Terminal and link this page (https://www.anchorterminal.com/terms/#data)

Cloud Run GPUs scores 68.4 (B) on agent readiness against Cerebrium's 52.5 (D), and leads in 6 of 7 scored categories. Cerebrium leads on payments & pricing. Both do gpu compute.

- Cerebrium: D 52.5, rank #983 of 1486 · https://www.anchorterminal.com/tools/cerebrium.min.md
- Cloud Run GPUs: B 68.4, rank #288 of 1486 · https://www.anchorterminal.com/tools/cloud-run-gpus.min.md
- Cerebrium, good for Teams serving their own models as real-time endpoints (voice, LLM, image) who want per-second billing, multi-region placement and a scriptable management API. Ahead on Payments & pricing, 30 against 20.
- Cloud Run GPUs, good for Serving small and mid-size open models, or batch jobs, from a container that should scale to zero. Ahead on Reliability, 70 against 48; Schema & documentation, 81 against 70; Agent ergonomics, 66 against 49; Security & auth, 78 against 60; Maintenance & community, 80 against 65; Transparency & trust, 84 against 64.

| Category | Cerebrium | Cloud Run GPUs |
| --- | --- | --- |
| Reliability (16%) | 48 | 70 |
| Performance (10%) | pending | pending |
| Schema & documentation (13%) | 70 | 81 |
| Agent ergonomics (13%) | 49 | 66 |
| Security & auth (14%) | 60 | 78 |
| Payments & pricing (10%) | 30 | 20 |
| Task success (10%) | pending | pending |
| Maintenance & community (7%) | 65 | 80 |
| Transparency & trust (7%) | 64 | 84 |

| Fact (where they differ) | Cerebrium | Cloud Run GPUs |
| --- | --- | --- |
| Vendor | Cerebrium Inc. | Google Cloud |
| Hosted endpoint | `https://rest.cerebrium.ai` | `https://run.googleapis.com` |
| Transports | HTTP |  |
| Auth | API key | OAuth |
| Pricing | Freemium | Pay per use |
| Licence | Proprietary service under Cerebrium's terms of service. The CLI is MIT | Proprietary service under the Google Cloud Platform terms. Client libraries are Apache-2.0 |
| llms.txt | yes | no |
| Last release | 2026-09-16 | 2026-10-30 |
| Terms last updated | no date given | 2026-09-02 |
| Privacy policy last updated | no date given | 2026-09-28 |
| Terms restrict automated access | yes | not found in the text |
| Terms or service can change without notice | yes | not found in the text |

Why the edge:
- Reliability, Cloud Run GPUs +22: Cerebrium 48 (Graded as a hosted service. Status page at status.cerebrium.ai with 11 components and 90 days of history, per the 8 October check, not re-read on 4 November (cerebrium.ai's terms bar robots and automatic means) (20). The 8 October reading covered the window to that day. Since 6 August it held degradations of 5 hours 7 minutes on 19 August (US, upstream) and 7 hours 20 minutes on 2 September (EU, provider network), both partial; 9 October to 4 November is unread, so the line keeps its recorded award (10). No request rate limits found. Plans publish concurrency caps of 5 GPUs and 500 containers on Hobby and 30 and 1,000 on Standard (5 of 15). No 429 or backoff guidance for callers found. Webhook forwarding retries failed deliveries and the docs ask for idempotent webhook receivers, partly met, kept (3 of 15). No SLA found. The 99.9 and 99.999 per cent uptime figures on the site are claims without terms (0). Endpoints, the CLI and the REST API are GA, while multi-region deployment and checkpointing are marked beta (10). Docs and status per the 8 October check, not re-read on 4 November. 20 + 10 + 5 + 3 + 0 + 10 = 48.); Cloud Run GPUs 70 (Hosted reading. Google Cloud's status page with a JSON incident feed (20). In the 90 days from 8 August 2026 the feed names Cloud Run in three multi-product incidents, a service outage on 20 August (15:40 to 19:20 UTC, 27 products, global and us-west1), a network degradation in us-central1-b on 1 September and a europe-west2 disruption on 20 October. One major (10). Resource limits and GPU quota are published with numbers (3 GPUs a region by default), but no request rate for the Admin API was found on the quotas page (10). Google's client libraries retry with backoff and the Admin API takes etags, while no GPU-specific retry guidance was found (10). An SLA for GPU services, 99.95% with zonal redundancy and 99.5% without (10). GPU services generally available since 7 April 2025 (10). 20+10+10+10+10+10 = 70.)
- Transparency & trust, Cloud Run GPUs +20: Cerebrium 64 (Closed service with published terms. The CLI is MIT (20). The docs say request and log data is deleted after 7 days on Hobby and 30 on Standard, that customer data is not used for training, and that a DPA is available on request. The privacy policy gives no retention periods, the pricing page shows both 1 day and 7 days of log retention for Hobby, and the docs still say SOC 2 Type I (15 of 30). No deprecation policy or dated notices found (0). Regions and some providers (AWS regions, Crusoe, Nebius) are named in the docs and status page, and Datadog, BugSnag and Stripe are named in passing, but no subprocessor list was found. The CLI's BugSnag error reporting is on by default and sends the user ID from the token and the project ID; `cerebrium config telemetry disable`, `CEREBRIUM_TELEMETRY_DISABLED` and, since 24 August, `DO_NOT_TRACK` turn it off. Its enable help says no personal data is sent, which the user ID contradicts; that is charged once, as the misleading-claim deduction, not on this line (10 of 20). Docs and policies per the 8 October check, not re-read on 4 November; terms re-read on 4 November. 20 + 15 + 0 + 10 = 45.); Cloud Run GPUs 84 (Closed service under the Google Cloud terms, with Apache-2.0 client libraries (15). The Cloud Data Processing Addendum and the privacy notice cover customer data, per the Document AI listing's 1 November reading; no Cloud Run statement on GPU instance data after shutdown was found (22). The Cloud terms promise 12 months' notice before a backwards-incompatible API change, and driver versions are announced in the release notes (16). Regions per GPU type listed, with Google's subprocessor list and data-location terms (16). 15+22+16+16 = 69.)
- Security & auth, Cloud Run GPUs +18: Cerebrium 60 (Service account tokens expire after up to one year (or never, if set to 0), are limited to 1 to 50 named projects and are revoked by deleting the account. Inference API keys are separate and can be deleted. No per-action scopes, and the CLI's SECURITY.md says tokens sit in plaintext in a config file with mode 0644 (20 of 30). Users have owner, member and billing roles, but tokens have no read-only form, and `disable_auth` defaults to true, so deployed endpoints answer without a token unless the owner changes it (5 of 20). Runs the owner's code and returns its output (10). Docs readings per the 8 October check, not re-read on 4 November. Audit log of 22 actions with actor, IP address and outcome, in the dashboard and over the API, on Standard (7 days) and Enterprise (30 days) only (12 of 15). SOC 2 Type II announced on 8 July 2026, HIPAA BAA on request, a trust centre, and disclosure to security@cerebrium.ai. No security.txt and no bug bounty found (13 of 20). No advisory for cerebrium on OSV on 4 November. 20 + 5 + 10 + 12 + 13 = 60.); Cloud Run GPUs 78 (OAuth 2.0 tokens from service accounts under IAM. Google's APIs accept `access_token` as a query parameter, the 10-point deduction other Google API listings take (20). IAM roles separate viewing, deploying and invoking, and services can require IAM authentication for every call (16). The platform runs your own container and returns its output (10). Cloud Audit Logs record Admin API calls, and request logs go to Cloud Logging (15). Google's vulnerability reward programme, security.txt and certifications (17). 20+16+10+15+17 = 78.)
- Agent ergonomics, Cloud Run GPUs +17: Cerebrium 49 (No field selection. A `limit` parameter on five list operations, and app and run objects are small (12 of 25). The audit log and runs page with `limit` and `nextToken` and filter by status, status code and time, though other lists use `page`, `pageSize` or `offset` (14 of 20). Errors are a `message` string with 400 or 401. Deployed endpoints return 200, 401, 403, 404 or 5xx, and a function can set its own `status_code` (10 of 20). No idempotency keys. Async calls return a `run_id` that can be listed and cancelled (5 of 20). Defaults are sensible (`min_replicas` 0, `cooldown` 60) and `cerebrium init` writes a working config, but there is a CLI only and no language SDK (8 of 15). Docs per the 8 October check, not re-read on 4 November; the CLI clone confirms `--output json` on list commands since 10 August. 12 + 14 + 10 + 5 + 8 = 49.); Cloud Run GPUs 66 (Platform reading. One `gcloud run deploy` with `--gpu` and `--gpu-type` adds a GPU to a container, and responses carry the service object with `fieldMask` on updates (15). List calls page with `pageSize` and `pageToken` (15). Google's status codes and messages, with quota errors that name the limit (12). Revisions are immutable, traffic can be moved back, and etags guard updates, but no idempotency key on create (12). Client libraries in many languages and gcloud, though a GPU deploy needs instance-based billing, minimum CPU and memory and, past 3 GPUs, a quota request (12). 15+15+12+12+12 = 66.)
- Maintenance & community, Cloud Run GPUs +15: Cerebrium 65 (CLI v2.9.0 tagged on 16 September 2026, 49 days before the check, the newest tag in the repository; commits since (20 and 21 October, licence notices and a Go 1.26.10 upgrade) are untagged (20). Five tagged releases since 6 August 2026 (v2.5.4 on 7 August, v2.6.0, v2.7.0, v2.8.0, v2.9.0) (20). Closed service with a Discord community and Slack or Intercom support by plan. No platform changelog, and we couldn't read the GitHub issue tracker (8 of 25). The CLI ships on PyPI, Homebrew and as binaries. There is no language SDK (10 of 15). The repository has lint and test workflows and now pins Go 1.26.10. CI status wasn't visible in the clone (7 of 10). 20 + 20 + 8 + 10 + 7 = 65.); Cloud Run GPUs 80 (Closed service with official SDKs. The newest GPU change is 30 October 2026, jobs with GPUs running up to 12 hours (30). Cloud Run release notes dated 4 November, 2 November, 30 October, 24 October and more in the 90 days (20). Release notes, Google Cloud support and public trackers for the client libraries, which were not read (10). Official client libraries in eight languages and gcloud (15). CI results not checked (5). 30+20+10+15+5 = 80.)
- Schema & documentation, Cloud Run GPUs +11: Cerebrium 70 (Public OpenAPI 3.0 spec for the management API with 94 operations on 73 paths. Deployed endpoints take whatever the owner's function defines (25). llms.txt and a .md twin of every docs page (10). Operation descriptions are one line each. The guides say when to use the protected tier, async runs or a custom runtime (12 of 20). Required fields are marked, but the spec has no enums (valid values such as member and billing sit in prose) and several arrays and objects are untyped (7 of 15). The guides carry many worked examples. The spec has no examples and documents only 400 and 401 errors with a `message` string (8 of 15). Paths are versioned v2, v3 and v4 and CLI releases are dated on GitHub, but the spec version is a fixed 1.0.0 and no platform changelog was found (8 of 15). Docs and spec per the 8 October check, not re-read on 4 November. 25 + 10 + 12 + 7 + 8 + 8 = 70.); Cloud Run GPUs 81 (API reading. A public Discovery document for the Cloud Run Admin API v2 (25). No llms.txt; Google's docs answer Markdown only at an unlinked `.md.txt` address, read as half, as for the Document AI listing (5). The GPU page says when to turn zonal redundancy on or off and the best-practices page when to bake models into images or load them from Cloud Storage (16). The GPU type is a free string in a node selector, with CPU and memory minimums stated in prose (9). gcloud, YAML, Terraform and console steps on each page, and errors follow Google's status model with no Cloud Run GPU error list (11). Versioned API (v1 and v2) and dated release notes (15). 25+5+16+9+11+15 = 81.)