mcpbeat Sign in

corpusAI Cloud Pricing MCP Server

by jtraversa Your server? Claim it
answering

corpusAI Cloud Pricing is answering right now. Last checked 13 min ago. 34 installs a week from npm. It exposes 35 tools. Last commit 27 Sep 2026.

Cloud, GPU and LLM token prices with index fixings. Pay per call over x402 or with a prepaid key.

Installs per day peak 444 · avg 45 · -74% w/w
a month agotoday
Uptime history 30 days of history · worst day 98%
30 days agonow
100.0%
Uptime 24h
91 of 91 checks
35
Tools
read from the server
367 ms
Response time
average over 24h
34
Installs / week
npm and PyPI

What changed 15

Every tool that appeared, vanished or quietly changed what it asks for. Recorded since 27 September 2026. No other catalogue keeps this.

27 Sep 8 tool descriptions were rewritten capacity_headline, capacity_stress, gpu_models and 5 more
27 Sep 5 tools changed the parameters they ask for capacity_history, capacity_stress, gpu_index and 2 more
27 Sep a tool appeared attestations
27 Sep a tool disappeared attestations

Nothing serious here today

Today is the operative word: we check corpusAI Cloud Pricing every 15 minutes and re-read its code on every release. Watch it and you find out the day that stops being true.

Three servers free · no card

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 13 min ago.

run in your terminal
claude mcp add corpus-cloud-pricing-mcp --transport http https://cloud.trycorpus.ai/mcp
Settings → Connectors → Add custom connector, then paste this address
https://cloud.trycorpus.ai/mcp
~/.codex/config.toml
[mcp_servers.corpus-cloud-pricing-mcp]
url = "https://cloud.trycorpus.ai/mcp"
.cursor/mcp.json
{
  "mcpServers": {
    "corpus-cloud-pricing-mcp": {
      "url": "https://cloud.trycorpus.ai/mcp"
    }
  }
}
.vscode/mcp.json
{
  "servers": {
    "corpus-cloud-pricing-mcp": {
      "type": "http",
      "url": "https://cloud.trycorpus.ai/mcp"
    }
  }
}

Available tools 35

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

spot
spot_daily
Paid (0.05 USDC per call). Full daily history for one instance type, all eras stitched. One row per UTC day from the earliest data for the type to now. Rows dated before the type's first raw event come from the legacy history (`source` = `pauley`: measured 2022-05 to 2024-01 AWS, open/high/low/close present on days the price moved; `titans`: daily average only, 2024 to 2026). Rows from `direct_from` on are time-weighted, zone-collapsed bars from the raw event store (`source` = `direct`, same method as /spot/hourly; `avg` equals the public dashboard value). open/high/low/close are null where the source only has an average.
spot_events
Paid (0.01 USDC per call). Raw spot price-change events for one instance type. Every price change for the type in the window, with exact timestamp, availability zone and product (OS). Sorted by time. Repeated identical prices are dropped by default (`include_repeats=true` keeps them). Up to `limit` rows; when `truncated` is true, continue with `from` = `next_from`.
spot_hourly
Paid (0.01 USDC per call). Hourly time-weighted OHLC bars for one instance type. Per-zone series are bucketed by UTC hour with time weighting (a price counts for as long as it was in force), then collapsed across zones: open/close/avg are the median across zones, high is the max, low is the min. Window is capped at 366 days.
spot_latest
Paid (0.01 USDC per call). Price currently in force per zone and product for one instance type. The most recent event of every (zone, product) series of the type, with its timestamp and age. A price is only meaningful while the provider still offers the type; AWS series older than ~10 days are likely retired, GCP/Azure reprice rarely so old timestamps are normal. For every type in a region at once use /spot/snapshot.
spot_monthly
Paid (0.05 USDC per call). Full monthly history for one instance type, back to 2014 for legacy AWS types. Calendar months from the earliest data to now. `months` is the curated series: `uscisi-adjusted` months (2017 to 2022-04, AWS types with a stable correction factor, average only), then months rolled up from the daily series (`pauley`, `titans`, `direct`: `avg` = median of daily averages, open/close from the first/last day, high/low the extremes, `days` = days covered, `source` = the source covering most days). `archive` (AWS, default on) is the USC/ISI monthly dataset 2014-02 to 2023-12 as published, with open/high/low/close, for 51 legacy types: third-party, mixes OS products, provenance partly unverified; returned separately so it never silently blends into the curated series.
spot_snapshot
Paid (0.10 USDC per call). Current price of every instance type, zone and product in a whole region, in one call. Bulk snapshot: the most recent event of every series in the region (about 6,000 rows for an AWS region), with timestamp and age per row. Same semantics as /spot/latest. Priced higher because one call returns the entire current price surface of the region.
tokens
tokens_board
Paid (0.10 USDC per call). Every model's input, output and blended fixing for one day, plus the frontier basket.
tokens_fixing
Paid (0.01 USDC per call). One day's token price fixing for a ticker such as CX.TOK.CLAUDESONNET5.IN. Median across every source and host at the standard tier (batch and free variants excluded). `.IN` and `.OUT` are input and output USD per million tokens; `.BLEND` is (3·input + output) / 4. `CX.TOK.FRONTIER.<side>` is the median across the frontier basket listed by /tokens/models.
tokens_history
Paid (0.05 USDC per call). Daily fixings for a token ticker, from the first snapshot (2026-09-14).
tokens_models
Free. Every LLM with a token price fixing, its ticker codes and today's price range. Canonical model slugs (for example `claude-sonnet-5`, `gpt-6-astra`, `llama-4-maverick`), their ticker codes, how many sources and hosts list them, and the min/max input and output price seen today. Also lists the frontier basket.
tokens_quotes
Paid (0.01 USDC per call). Every listed price for one model on one day: each source and hosting provider, USD per million tokens. Rows from the OpenRouter catalog, OpenRouter per-host endpoints (Azure, Amazon Bedrock, Google, Together, DeepInfra, …), the LiteLLM price table and DeepInfra. Includes cache-read price and context length where known; variants such as batch tiers are marked in `extra.variant`.
capacity
capacity_board
Paid (0.10 USDC per call). Every GPU model's capacity stress score for one day, tightest first.
capacity_headline
Free. Capacity stress score per GPU model for the latest day, score only. Rounded score from 0 (slack) to 100 (tight) per GPU with at least two signals, tightest first, cached ten minutes. The components and their inputs are in the paid /capacity/stress and /capacity/board.
capacity_history
Paid (0.05 USDC per call). Daily capacity stress scores for one GPU model.
capacity_stress
Paid (0.01 USDC per call). Capacity stress score, 0 (slack) to 100 (tight), for one GPU model on one day, with every component. Mean of the components available that day: availability (share of Shadeform and Lambda listings flagged available), ionet (deployable ÷ total units on io.net regional SKUs), supply (Vast on-demand offers vs the trailing 30-day median) and spot_ratio (hyperscaler SPOT fixing ÷ HYP fixing, 0.3 → 0 and 0.9 → 100). Each component carries its inputs.
gpu
gpu_index
Paid (0.05 USDC per call). Daily USD per GPU-hour index per provider and market for one GPU model, with hyperscaler spot legs. For each snapshot day and (provider, market): number of quotes and the lowest, median, mean and highest USD per GPU-hour. Rows with provider `aws-spot` or `gcp-spot` are computed from our own spot price events for the instance family that carries the GPU (time-weighted daily bar divided by GPUs per node, per region), so the neo-cloud market and hyperscaler spot are comparable in one series. Quote history starts 2026-09-13; hyperscaler spot legs reach back to the start of our event data.
gpu_models
Free. GPU models with rental quotes, and which providers quote them. Normalized model names (use verbatim as `gpu`), number of providers quoting each, quote counts, first/last snapshot day, the lowest observed USD per GPU-hour, and which hyperscaler spot instance families map to the model.
gpu_quotes
Paid (0.01 USDC per call). Latest rental quotes for one GPU model across neo-clouds, marketplaces and other clouds. One row per quote in each provider's latest daily snapshot: provider, market (`ondemand`, `spot` = interruptible, `bid` = marketplace minimum bid, `secure`/`community` = RunPod tiers), GPUs in the quoted unit, USD per GPU-hour, quoted unit price, region where the provider exposes one, and provider-specific detail in `extra` (marketplace host reliability, VRAM, stock status). Sources are each provider's public price feed or page (Vast.ai: the cheapest 64 offers per model, on-demand and bid); /gpu/models lists who quotes each model. Snapshots are taken several times a day.
gpu_snapshot
Paid (0.10 USDC per call). Every GPU model × provider × market: lowest and median USD per GPU-hour in the latest snapshot, plus hyperscaler spot per region.
index
index_board
Paid (0.10 USDC per call). Every ticker's fixing for one day in one call.
index_fixing
Paid (0.01 USDC per call). One day's fixing for a ticker: median USD per GPU-hour of eligible quotes, with low, high and count. Quote segments (MKT, AGG, NEO, INT, EXE, HYP) fix from that day's snapshots; the default day is the latest snapshot. SPOT fixes from the full UTC day of spot events, so the default is yesterday; SPOT composites carry per-region values and spread_vs_neo. See /methodology for eligibility and aggregation.
index_history
Paid (0.05 USDC per call). Daily fixings for a ticker over a date range. Quote segments start 2026-09-13. SPOT tickers reach back to the start of the spot series (AWS daily from 2022-05-31 for A100, V100, T4, A10; from 2023-07 for H100), each row carrying its data source.
index_tickers
Free. Every index ticker, its segment and definition. Tickers are CX.<MODEL>.<SEGMENT> (for example CX.H100SXM.NEO) or CX.<MODEL>.SPOT.<REGION>. Includes the segment membership lists and the methodology version.
ondemand
ondemand
Paid (0.01 USDC per call). On-demand list-price history of one instance type. Change-point series: one row per day the on-demand (pay-as-you-go) hourly list price changed; `current` is the price in force. AWS: Linux, shared tenancy, from the AWS Price List API, refreshed weekly, since 2024-01 (every AWS region in /catalog). Azure: every Linux VM SKU from the public Retail Prices API, refreshed daily, since 2026-09-13 (every Azure region in /catalog). GCP: the TITANS-era series (2024 to 2026-08), not refreshed.
ondemand_snapshot
Paid (0.10 USDC per call). Current on-demand list price of every instance type in a region.
reserved
reserved
Paid (0.01 USDC per call). Reserved / reservation price history of one instance type (AWS standard RIs 1y/3y no-upfront/all-upfront; Azure reservations 1y/3y). Effective hourly USD with any upfront amortized over the term, as change-point series per `ri_type` (`ri_1y_no_upfront_standard`, `ri_1y_all_upfront_standard`, `ri_3y_no_upfront_standard`, `ri_3y_all_upfront_standard`; GCP `cud_1y`, `cud_3y`). AWS: Linux, shared tenancy, history back to 2016 for the original three regions, weekly refresh from the AWS Price List API. Azure: all-upfront reservations from the public Retail Prices API, daily, since 2026-09-13. GCP: resource-based committed-use discounts from the Cloud Billing Catalog (vCPU, RAM and GPU commitment SKUs), daily, since 2026-09-13.
reserved_snapshot
Paid (0.10 USDC per call). Current reserved effective hourly price of every instance type and ri_type in a region (AWS or Azure).
term
term
Paid (0.05 USDC per call). Term structure per hyperscaler for one GPU model, USD per GPU-hour: spot, on-demand, 1y, 3y. For each hyperscaler with a mapped instance family (see /gpu/models hyperscaler_spot_legs), the median across regions of each term's price divided by GPUs per node, with lo/hi across regions and the discount to on-demand. Answers "what does a committed H100 cost against spot and on-demand, per cloud". Neo-cloud commitment prices are quote-only and excluded.
term_instance
Paid (0.01 USDC per call). Price ladder for one instance type: spot, on-demand, 1-year and 3-year commitments, with discounts. Current prices from our series: spot median across zones (where spot events exist), on-demand list price, and reserved/reservation terms as effective hourly with upfront amortized. `discount_pct` is relative to on-demand. AWS carries four reserved terms (1y/3y × no/all upfront), Azure two (1y/3y all upfront), GCP two resource-based committed-use terms (`cud_1y`, `cud_3y`, no upfront).
attestations
attestations
Free. Daily on-chain attestations of the fixing set. One record per store day: the keccak256 of the day's signed fixings file (served at /attest/<day>.json), the Ethereum Attestation Service UID and transaction on Base (eip155:8453), the publisher address and the schema UID. Re-hash the file bytes and compare with fixingsHash to verify; every row inside the file carries its own EIP-712 signature. See /governance.
azure
azure_eviction
Paid (0.01 USDC per call). Azure spot eviction-rate history (28-day buckets, sampled daily). Daily samples of the eviction-rate bucket Azure reports per SKU (`0-5`, `5-10`, `10-15`, `15-20`, `20+` percent over the trailing 28 days). Collected daily since 2026-09-05; there is no history before the first sample.
catalog
catalog
Free. Providers, regions, coverage window and event counts. One row per (provider, region) with raw-event coverage (instance types, events, first/last event) and legacy-history coverage (daily and monthly date ranges), plus `sources`, the legend explaining every `source` value returned by /spot/daily and /spot/monthly. Use the `region` values here verbatim in every other call.
health
health
Free. Liveness and store readiness. Returns 200 whenever the server is up. `ready` is false while the store is still ingesting after a restart; paid endpoints answer 503 (and take no payment) until it is true.
instances
instances
Free. Instance types available in a region. Exact type names with per-type coverage: raw events (`events`, `first_event`, `last_event`; zero/null for types that only exist in the legacy history) and legacy history ranges (`history_daily_from/to`, `history_monthly_from/to`). Optional `prefix` narrows the list (for example `c5.` or `n2-`).
status
status
Free. Freshness of every data source. Per source: last successful snapshot or event, staleness in days, and the public URL it is read from. Use it to decide whether a fixing or quote is current before paying for it.

Endpoints

URLTransportStateLatencyChecked
https://cloud.trycorpus.ai/mcp streamable-http answering 317 ms 13 min ago

Alternatives to corpusAI Cloud Pricing

same job, measured the same way
Foundry: prepaid AI compute in USDF
by usdf

Prepaid AI compute in USDF: models, quotes and chat with a receipt; pay per call (x402) or by key

10 tools answering
FX Reference Rates
by workers-regnotes-fx-reference-rates

ECB FX rates, cloud GPU and LLM API prices, World Bank country macro data; pay per call via x402

9 tools answering
Mapleai MCP
by veenrek

Pay-per-request GPT chat, embeddings, agents and prepaid keys with local x402 USDC signing

42 installs/wk local only
O
OmniProvider
by omnidev

Pay-per-call LLM API for agents: model catalog, pricing, unpaid x402/MPP quotes, how-to-pay.

4 tools answering
Base Web3 M2m Hub
by castralis122

Live Base Mainnet on-chain data (gas, DEX, Aave, token risk, prices). Pay per call in USDC via x402.

17 tools answering
agentpay — card-funded wallets for AI agents
by entangleit

Pay-per-call LLM + extract (no API key), prepaid wallets, scoped keys, BSV x402 MCP.

27 tools answering
47620 Solana Data
by 47620-xyz

Pay-per-call Solana data for AI agents over x402: token, account, tx, trending. No signup, no key.

52 tools answering
Distill
by spencermcw-data

Pre-computed answers with sources and confidence, paid per call over x402 (USDC on Base).

19 tools answering

corpusAI Cloud Pricing — questions

Answers built from our own checks of this server.

What can corpusAI Cloud Pricing do?
It exposes 35 tools, read directly from the server on our last check. Among them: attestations, azure_eviction, capacity_board, capacity_headline, capacity_history, capacity_stress and 29 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →
What is corpusAI Cloud Pricing mostly used for?
Its tools cluster around spot, tokens and gpu. That is what this server is built to work with — the grouping comes from the actual tool names, not from a category we assigned.
Is corpusAI Cloud Pricing working right now?
We send a real MCP handshake every 15 minutes. Over the last 24 hours 91 of 91 checks got a reply (100.0%), average response time 367 ms. The bar chart above shows every period we have measured.
How do I connect corpusAI Cloud Pricing?
Copy the ready config from this page. We generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each in the form that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.
Does corpusAI Cloud Pricing need an API key?
No. corpusAI Cloud Pricing completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 35 of them are readable on this page. This is what we observed, not what the docs claim.
How fast is corpusAI Cloud Pricing?
It answers our handshake in 367 ms on average, which is faster than 41% of all working MCP servers we measure. The comparison comes from our own checks across the whole registry, every 15 minutes.
How many people use corpusAI Cloud Pricing?
The npm package corpus-cloud-pricing-mcp was installed 34 times in the last week. Week over week that is -74%. We show installs rather than GitHub stars on purpose: a star is a bookmark, an install is someone actually running it.
Is corpusAI Cloud Pricing open source?
The code is open source: it is published under the MIT licence, written in JavaScript and 0 stars on GitHub. The licence covers the code in the repository, not the hosted service at cloud.trycorpus.ai, which runs on its operator's own terms.