# Authentication (/authentication)
Send your key in the `Authorization` header of every request:
```bash
curl https://data.tryopengrid.com/v1/gpus \
-H "Authorization: Bearer opg_live_..."
```
Nothing on `data.tryopengrid.com` is anonymous. A request without a valid key gets a `401` in the standard
[error shape](/errors).
## Getting a key [#getting-a-key]
The Data API is offered to companies under an enterprise agreement, and the OpenGrid team issues every key. Email
with:
- your company and a contact,
- what you plan to build,
- how many requests per minute you expect.
You will receive a key that starts with `opg_live_`, followed by 43 random characters. OpenGrid stores only a keyed
hash of it, so a lost key cannot be recovered, only replaced.
## Scopes [#scopes]
A key carries scopes. The Data API needs `data:read`. A key without it gets `403 permission_denied`.
## Keeping keys safe [#keeping-keys-safe]
- Keep keys in environment variables or a secret manager, never in source code or a client-side app.
- Use one key per application, so you can replace one without touching the others.
- If a key may have leaked, ask us to revoke it. Revocation takes effect on the next request.
Do not ship your key in a web page or mobile app. Call the API from your server. The docs playground is the one
exception: it runs in your own browser, and the key you paste never leaves it except to `data.tryopengrid.com`.
## Errors [#errors]
| Status | `code` | When |
| --- | --- | --- |
| `401` | `authentication_required` | No `Authorization` header, or the key is malformed, unknown, revoked or expired. |
| `403` | `permission_denied` | The key lacks `data:read`, or the account is suspended. |
| `429` | `rate_limited` | Over the key's or the account's rate limit. See [Rate limits](/rate-limits). |
# Bulk exports (/bulk-exports)
For backfills and warehouses, download whole days instead of paging.
```bash
curl -o listings-2026-11-05.jsonl.gz \
"https://data.tryopengrid.com/v1/exports/listings?date=2026-11-05" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
gunzip -c listings-2026-11-05.jsonl.gz | head -1
```
## Datasets [#datasets]
| Dataset | One line per |
| --- | --- |
| `listings` | Public listing as it stood at 23:59:59 UTC that day (the [point-in-time](/point-in-time) read). |
| `listing_changes` | Recorded change of price, availability or capacity during the day. |
| `index_levels` | Public index per hour of the day. |
| `fixings` | Official fixing taken for a time in the day. |
`GET /v1/exports` lists the datasets and the first day each one has data.
## Rules [#rules]
- `date` must be a **completed** UTC day, yesterday or earlier. Today is a `422`.
- The file is `application/gzip`, one JSON object per line, named `opengrid--.jsonl.gz`.
- Rows follow the same [data rules](/data-rules) as the API: ids, `Z` timestamps, and fixing values as strings.
- A past day never changes, so cache it. Responses carry `Cache-Control: private, max-age=86400`.
## Loading into a warehouse [#loading-into-a-warehouse]
```python
import gzip
import json
import os
from datetime import date, timedelta
import requests
day = (date.today() - timedelta(days=1)).isoformat()
r = requests.get(
f"https://data.tryopengrid.com/v1/exports/listings?date={day}",
headers={"Authorization": f"Bearer {os.environ['OPENGRID_API_KEY']}"},
timeout=300,
)
r.raise_for_status()
rows = [json.loads(line) for line in gzip.decompress(r.content).splitlines() if line]
print(len(rows), "listings on", day)
```
# Caching (/caching)
Every successful `GET` carries:
```http
ETag: "3f2a9c..."
Cache-Control: private, max-age=60
Vary: Authorization, OpenGrid-Version
```
- **`ETag`** identifies the data and the API version. It ignores `as_of` and `request_id`, so it only changes when the data does.
- **`Cache-Control: private, max-age=60`**: your client may reuse a response for 60 seconds. Shared caches and CDNs
must not store it.
## Conditional requests [#conditional-requests]
Send the last `ETag` back in `If-None-Match`. If nothing changed, you get `304 Not Modified` with no body:
```bash
curl -i https://data.tryopengrid.com/v1/markets \
-H "Authorization: Bearer $OPENGRID_API_KEY" \
-H 'If-None-Match: "3f2a9c..."'
# HTTP/2 304
```
```python
etag, cached = None, None
def markets(session):
global etag, cached
r = session.get("https://data.tryopengrid.com/v1/markets",
headers={"If-None-Match": etag} if etag else {})
if r.status_code == 304:
return cached
r.raise_for_status()
etag, cached = r.headers.get("ETag"), r.json()
return cached
```
A `304` still counts against your [rate limit](/rate-limits), but it is faster and carries no body.
## Exports [#exports]
A completed day's [bulk export](/bulk-exports) never changes, so it carries `Cache-Control: private, max-age=86400`.
# Changelog (/changelog)
Additive changes ship without a new version. Breaking changes get a new dated version. See [Versioning](/versioning).
## 2026-11-06 [#2026-11-06]
Additive, in version `2026-11-03`:
- `GET /v1/markets?trend=true` adds `change` (the lowest price's move over `hours`) and `trend` (that price on a
shared time grid, times in `meta.trend_times`). Every market row now names `low_provider` and `high_provider`.
- New `GET /v1/markets/{gpu}/history/providers`: each provider's price line for a GPU on one time grid, with the
market low, median and high.
- `GET /v1/listings?previous=true` adds `price_change`: the price before the listing's latest change, and when it
changed.
- Error `docs_url` now links to the [Errors](/errors) page on this site.
- The API answers CORS requests from this site, so the playground can call it with your key.
## 2026-11-03 [#2026-11-03]
First version of the Data API: `data.tryopengrid.com/v1`, dated versioning, one error shape, stable ids, cursor
pagination, ETags, point-in-time listings and bulk exports.
# Data rules (/data-rules)
These rules hold on every Data API response.
## Prices [#prices]
- Every price row has `price_per_gpu_hour` in **USD**. Beside it are the instance price, the currency and the
`gpu_count`, so you can rebuild the provider's own number.
- If the GPU count of an offer is unknown, `price_per_gpu_hour` is `null`. It is never guessed.
- A provider that prices in another currency keeps its original price in `original`, with the exchange rate used
(`fx.rate`, `fx.date`, `fx.source`). See `GET /v1/fx/rates`.
- Aggregates across providers are named `price: {low, median, high, currency, unit}`.
## Numbers [#numbers]
- Stored values are returned exactly as stored, never rounded.
- Computed statistics (medians, spreads, ratios) are cleaned of floating-point noise to 12 significant digits, so
`2.4215999999999998` is returned as `2.4216`.
- **Fixing values are decimal strings**, such as `"2.2494934019"`, not JSON numbers, because contracts may settle on
them. Parse them with a decimal type, not a float.
## Timestamps [#timestamps]
ISO 8601 in UTC, always ending in `Z`: `2026-11-06T14:00:00Z`.
Rows carry their own times. `observed_at` is when OpenGrid last saw the value, and `first_seen_at` is when the
offer first appeared. Use these, not `meta.as_of`, to judge freshness.
## Missing values [#missing-values]
A field is always present. When a value is unknown it is `null`, never omitted, so `"capacity": null` means the
provider doesn't report it.
## Names and enums [#names-and-enums]
- Field names are `snake_case`.
- Enum values are lowercase strings, such as `on_demand` and `spot`. New values can appear at any time: treat unknown
values as "other".
## Corrections [#corrections]
Nothing is corrected silently.
- **Listing history is append-only.** A past observation is never rewritten.
- **Suspicious values are held before publishing.** A price that fails checks is quarantined, and its `trust` block
says `held`, so a published price doesn't get quietly edited later.
- **Fixings are corrected by restatement.** The original stays, and the correction is listed with its reason in
`GET /v1/fixings/restatements`.
## Licence [#licence]
Data is licensed for your internal use under your agreement. It may not be republished or resold. See
[Terms](/terms).
# Errors (/errors)
Errors use standard HTTP status codes and one body shape (see [Responses](/responses#errors)). `error.code` is part
of the contract: it never changes meaning within a version. `error.message` is for humans and may change.
`error.type` groups codes:
| `type` | Status | Retry? |
| --- | --- | --- |
| `invalid_request` | 400, 404, 405, 409, 413, 415, 422 | No. Fix the request. |
| `authentication` | 401 | No. Check the key. |
| `permission` | 403 | No. Ask us about access. |
| `rate_limit` | 429 | Yes, after `Retry-After` seconds. |
| `api_error` | 5xx | Yes, with backoff. Quote `request_id` if it persists. |
## 400 [#400]
### bad_request [#bad_request]
The request is malformed in a way not covered by a more specific code.
### unknown_api_version [#unknown_api_version]
The `OpenGrid-Version` header is not a supported date. The message lists the supported ones. See
[Versioning](/versioning).
### invalid_cursor [#invalid_cursor]
The `cursor` was not issued by this API for this list. Pass back `meta.next_cursor` exactly as you received it.
## 401 [#401]
### authentication_required [#authentication_required]
No `Authorization: Bearer` header, or the key is malformed, unknown, revoked or expired. The message says which.
## 403 [#403]
### permission_denied [#permission_denied]
The key lacks the `data:read` scope, or the account is suspended.
## 404 [#404]
### not_found [#not_found]
No such resource or route: an unknown GPU, provider, index, fixing, story, or a typo in the path. GPU and
provider ids are listed by `GET /v1/gpus` and `GET /v1/providers`.
### unknown_series [#unknown_series]
The macro series id is not in `GET /v1/macro/series`.
## 405 [#405]
### method_not_allowed [#method_not_allowed]
The route exists but not for this method. Almost every Data API route is `GET`.
## 409 [#409]
### conflict [#conflict]
The request conflicts with the current state of a resource. Data API reads don't return it.
## 413 [#413]
### payload_too_large [#payload_too_large]
The request body is too large. `POST /v1/costs/estimate` returns `body_too_large` (at most 16,384 bytes).
## 415 [#415]
### unsupported_media_type [#unsupported_media_type]
The body's media type isn't accepted. `POST /v1/costs/estimate` returns `json_required`: send
`Content-Type: application/json`.
## 422 [#422]
### invalid_parameter [#invalid_parameter]
A query or path parameter failed validation. `error.param` names it and `error.message` says what is allowed.
`POST /v1/costs/estimate` returns specific codes for its body: `invalid_json`, `unknown_field`, `invalid_preset`,
`invalid_gpu`, `invalid_storage_class`, `missing_count` and `missing_hours`, plus `invalid_` for an
out-of-range number.
## 429 [#429]
### rate_limited [#rate_limited]
Over your key's or your account's budget for this request class. Wait `Retry-After` seconds and retry. See
[Rate limits](/rate-limits).
## 5xx [#5xx]
### internal_error [#internal_error]
Something failed on our side. Retry with exponential backoff, and contact us with the `request_id` if it persists.
### bad_gateway [#bad_gateway]
An upstream component did not answer correctly. Retry with backoff.
### unavailable [#unavailable]
The service is temporarily unavailable, for example during a deploy. Retry with backoff.
### timeout [#timeout]
The request took too long. Retry, or narrow it (a shorter `window`, a smaller `limit`).
# For AI agents (/for-agents)
These docs are built to be read by tools as well as people.
| Resource | URL | What it is |
| --- | --- | --- |
| `llms.txt` | [`/llms.txt`](/llms.txt) | Index of every page, with a one-line description each. |
| `llms-full.txt` | [`/llms-full.txt`](/llms-full.txt) | Every page, guides and API reference, as one markdown file. |
| Markdown per page | add `.md` to any URL, such as [`/quickstart.md`](/quickstart.md) | One page as markdown. |
| Content negotiation | any page with `Accept: text/markdown` | The same markdown, at the page's own URL. |
| OpenAPI | [`/openapi.json`](/openapi.json) | The Data API's OpenAPI 3.1 schema, generated from the API's code. |
Every page also has **Copy Markdown** and **Open in ChatGPT, Claude or Cursor** buttons under its title.
## Give your assistant the docs [#give-your-assistant-the-docs]
Add `https://docs.tryopengrid.com/llms-full.txt` under **Settings, Indexing & Docs, Add Doc**, then reference it
with `@OpenGrid` in chat.
```text
Read https://docs.tryopengrid.com/llms-full.txt, then write a script that prints the cheapest
available H100 SXM5 listing from the OpenGrid Data API. My key is in OPENGRID_API_KEY.
```
Point it at `https://docs.tryopengrid.com/llms.txt` and let it fetch the pages it needs as `.md`, or give it
`https://docs.tryopengrid.com/openapi.json` to generate a typed client.
## Tips for generated code [#tips-for-generated-code]
- Send `OpenGrid-Version: 2026-11-03` on every request, so generated code doesn't change shape under you.
- Read the key from an environment variable. Never paste it into a prompt.
- Branch on `error.code`, not on `error.message`.
- Page with `meta.next_cursor` until it is `null`.
# Estimate a job's full cost (/guides/estimate-job-cost)
The cheapest GPU-hour isn't always the cheapest job. `POST /v1/costs/estimate` prices a whole job on every provider
that lists the GPU: compute, egress and storage, with billing increments applied.
```bash
curl -X POST https://data.tryopengrid.com/v1/costs/estimate \
-H "Authorization: Bearer $OPENGRID_API_KEY" \
-H "Content-Type: application/json" \
-d '{"gpu": "nvidia-h100-80gb-sxm5", "count": 8, "hours": 24, "egress_tb": 2, "storage_tb": 5}'
```
## The job [#the-job]
| Field | Type | Notes |
| --- | --- | --- |
| `gpu` | string | GPU id or alias. Required unless a `preset` sets it. |
| `count` | integer | GPUs, 1 to 1,024. |
| `hours` | number | Duration, 1 minute to 8,760 hours. |
| `egress_tb` or `egress_gb` | number | Data out. Give one, not both. |
| `storage_tb` or `storage_gb` | number | Data stored for the job. Give one, not both. |
| `storage_class` | string | `auto` (default), `shared_fs`, `block_storage` or `object_storage`. |
| `min_fabric_gbps` | number | Only providers with at least this interconnect. |
| `preset` | string | Start from a reference job (`GET /v1/costs/presets`) and override any field. |
Terabytes are decimal: 1 TB = 1,000 GB. Unknown fields are a `422 unknown_field`.
## Reading the result [#reading-the-result]
`data` is one row per provider, cheapest total first. When OpenGrid can't verify a component (the provider doesn't
publish it), the row lists it in `unknown`, sets `total_is_lower_bound: true`, and sorts after the complete totals. `meta` repeats the parsed `job`,
lists providers it couldn't rank in `unranked`, and counts the lower-bound rows.
Estimates use published list prices. Negotiated discounts aren't included.
## Inputs you can inspect [#inputs-you-can-inspect]
- `GET /v1/costs/components`: egress and storage prices per provider.
- `GET /v1/costs/billing`: billing increments and minimums per provider.
- `GET /v1/costs/sources`: where each number comes from, and when it was last fetched.
# Track GPU prices (/guides/track-gpu-prices)
This guide builds a small price tracker for the H100 SXM5. Every step is one request.
## 1. Find the GPU's id [#1-find-the-gpus-id]
```bash
curl "https://data.tryopengrid.com/v1/gpus?family=h100" -H "Authorization: Bearer $OPENGRID_API_KEY"
```
Each row's `id` (here `nvidia-h100-80gb-sxm5`) is what every other route takes. See [IDs](/ids).
## 2. The market now, with its 24-hour move [#2-the-market-now-with-its-24-hour-move]
`trend=true` adds `change` (the lowest price's move over `hours`) and `trend` (that price on a time grid, for a
sparkline):
```bash
curl "https://data.tryopengrid.com/v1/markets?trend=true&hours=24&points=48" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
```json
{
"gpu": "nvidia-h100-80gb-sxm5",
"price": { "low": 1.6168, "median": 2.4216, "high": 2.9269, "currency": "USD", "unit": "gpu_hour" },
"low_provider": "vast",
"change": { "pct": -0.032, "since": "2026-11-05T14:00:00Z", "hours": 24 },
"trend": [1.67, 1.67, 1.65, "..."]
}
```
`change.pct` is a fraction: `-0.032` is a 3.2% drop. It is `null` when there isn't enough history to compare.
The grid's times are in `meta.trend_times`.
## 3. History [#3-history]
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/history?window=30d&segment=on_demand" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
`data.series` holds points `{t, low, median, high, providers}`, and `data.index` holds the GPU's index line on the
same window. Windows are `24h`, `7d`, `30d`, `90d`, `ytd` and `all`. Use `segment=spot` for interruptible capacity.
For one line per provider, call `GET /v1/markets/nvidia-h100-80gb-sxm5/history/providers?hours=168`.
## 4. The cheapest available offer [#4-the-cheapest-available-offer]
```bash
curl "https://data.tryopengrid.com/v1/listings?gpu=nvidia-h100-80gb-sxm5&available=true&market_type=on_demand&limit=5" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
Listings come cheapest first. Each row has `provider`, `region`, `gpu_count`, `price_per_gpu_hour`,
`price_per_instance_hour`, `observed_at` and a `trust` block. Add `previous=true` to get each listing's
`price_change` (the price before its latest change, and when it changed).
## 5. Poll politely [#5-poll-politely]
Prices move at each provider's polling interval (15 to 60 minutes). Poll `GET /v1/markets` once a minute at most,
with [`If-None-Match`](/caching), and you'll stay well inside your [rate limit](/rate-limits).
## Put together [#put-together]
```python
import os
import requests
API = "https://data.tryopengrid.com/v1"
s = requests.Session()
s.headers.update({"Authorization": f"Bearer {os.environ['OPENGRID_API_KEY']}", "OpenGrid-Version": "2026-11-03"})
gpu = "nvidia-h100-80gb-sxm5"
markets = s.get(f"{API}/markets", params={"trend": "true", "hours": 24}).json()["data"]
row = next(m for m in markets if m["gpu"] == gpu)
cheapest = s.get(f"{API}/listings", params={"gpu": gpu, "available": "true", "limit": 1}).json()["data"][0]
print(f"{row['gpu_name']}: low ${row['price']['low']:.2f}/GPU-h, median ${row['price']['median']:.2f}")
if row.get("change") and row["change"]["pct"] is not None:
print(f"24h change: {row['change']['pct'] * 100:+.1f}%")
print(f"cheapest now: {cheapest['provider_name']} {cheapest['region']} at ${cheapest['price_per_gpu_hour']:.2f}")
```
# Use and verify fixings (/guides/verify-fixings)
A **fixing** is an index level taken at a scheduled time and published as an official value. Fixings are recorded in
an append-only ledger where each entry is hash-linked to the one before. A fixing can't be changed without the
change showing up.
## Latest fixings [#latest-fixings]
```bash
curl https://data.tryopengrid.com/v1/fixings -H "Authorization: Bearer $OPENGRID_API_KEY"
```
`data.indices` holds each settlement index with its latest hourly and daily fixings, and any provisional value still
waiting to be finalised. `data.ledger_head` is the newest ledger entry.
Fixing values are strings such as `"2.2494934019"`. Parse them with a decimal type (`decimal.Decimal`,
`BigDecimal`), never a float, so no rounding creeps in before settlement.
## One index's fixings [#one-indexs-fixings]
```bash
curl "https://data.tryopengrid.com/v1/indices/h100-80gb-sxm5/fixings" -H "Authorization: Bearer $OPENGRID_API_KEY"
```
## Verify a fixing [#verify-a-fixing]
`GET /v1/fixings/{fixing}/verify` recomputes the fixing from its stored inputs and checks its hashes and its links
to its neighbours. `GET /v1/fixings/chain/verify` checks the whole ledger:
```json
{ "ok": true, "checked": 18240, "break_count": 0, "breaks": [], "head_seq": 18240, "head_hash": "9c1e..." }
```
Store `head_hash` alongside the fixings you settle on. If you call `chain/verify` later and it still passes with the
same history, nothing you relied on was altered.
## Corrections [#corrections]
A wrong fixing is never edited. It is **restated**: a new ledger entry carries the corrected value and the reason,
and the original stays. `GET /v1/fixings/restatements` lists every restatement.
## Methodology [#methodology]
`GET /v1/fixings/methodology` gives the schedule, thresholds and correction rules as data. The full method of every
index is in `GET /v1/methodology/indices`.
# IDs (/ids)
IDs are frozen. Once published, an ID always means the same thing and is never renamed. IDs are never derived from
display names, so a provider renaming a product doesn't change anything you store.
| Thing | Format | Examples | Listed by |
| --- | --- | --- | --- |
| GPU | `vendor-model-memory-variant` | `nvidia-h100-80gb-sxm5`, `amd-mi300x-192gb`, `google-tpu-v5e` | `GET /v1/gpus` |
| GPU family | short name | `h100`, `hopper` | `GET /v1/families` |
| Provider | provider name | `lambda`, `runpod`, `aws` | `GET /v1/providers` |
| Index | GPU, then segment | `h100-80gb-sxm5`, `h100-80gb-sxm5.spot` | `GET /v1/indices` |
| Region group | name | `US`, `Europe`, `APAC` | `GET /v1/regions` |
## Names beside IDs [#names-beside-ids]
Every `gpu` field holds the ID, with the display name beside it in `gpu_name`. Every `provider` field holds the ID,
with `provider_name` beside it:
```json
{ "gpu": "nvidia-h100-80gb-sxm5", "gpu_name": "NVIDIA H100 80GB SXM5", "provider": "lambda", "provider_name": "Lambda" }
```
Store the ID and display the name.
## Aliases [#aliases]
As input, older short names and full names are accepted. `h100-80gb-sxm5` and `NVIDIA H100 80GB SXM5` both resolve
to `nvidia-h100-80gb-sxm5`. Responses always return the ID.
A family id where a GPU is expected, such as `GET /v1/gpus/h100`, is a `404` that points you to
`/v1/families/{family}`, because a family has several variants with different prices.
## Index IDs [#index-ids]
Index IDs keep their original form (`h100-80gb-sxm5`) and are not prefixed with the vendor. They are part of the
fixings hash chain, so renaming them would break verification. Each index names its GPU in its `gpu` field.
## Unmapped offers [#unmapped-offers]
A listing whose GPU OpenGrid couldn't identify has `gpu: null` and keeps the provider's own `raw_gpu_name`.
# Introduction (/)
The OpenGrid Data API gives you the GPU compute market as data: every price OpenGrid observes across cloud and
marketplace providers, the indices and fixings built from them, capacity, the full cost of a job, provider
reliability, market events and news.
```txt title="Base URL"
https://data.tryopengrid.com/v1
```
Every request needs an API key. Every response says how fresh its data is.
Make your first request in two minutes.
Every endpoint, its fields, and a playground to call it with your key.
How to get a key and send it.
llms.txt, markdown pages and the OpenAPI schema.
## What you can get [#what-you-can-get]
| Area | What it answers | Start with |
| --- | --- | --- |
| Markets | What does an H100 cost right now, across every provider? | `GET /v1/markets` |
| Listings | Which exact offers exist, where, and are they in stock? | `GET /v1/listings` |
| History | How has that price moved over 24 hours, 90 days, or as far back as archives go? | `GET /v1/markets/{gpu}/history` |
| Indices and fixings | What is the reference price of a GPU, and can I verify it? | `GET /v1/indices`, `GET /v1/fixings` |
| Capacity | What do providers report as available? | `GET /v1/capacity` |
| Costs | What does a whole job cost, with egress and storage? | `POST /v1/costs/estimate` |
| Reliability | Is a provider's API up, and how fresh is its data? | `GET /v1/reliability/providers` |
| Events and news | What changed in the market, and what was reported? | `GET /v1/events`, `GET /v1/news` |
## How it works [#how-it-works]
OpenGrid polls each provider's own API or price list every 15 to 60 minutes. It maps every offer to a canonical
GPU, converts it to USD per GPU-hour, and checks it before publishing. Every row carries when it was observed, and
corrections are never silent.
The Data API is available to companies under an enterprise agreement. To get a key, contact us at .
# Pagination (/pagination)
Lists return at most `limit` items (default `100` on most routes, maximum `1000`). When there are more, `meta`
holds a `next_cursor`. Pass it back as `cursor` to get the next page, until `next_cursor` is `null`.
```json
"meta": { "limit": 100, "next_cursor": "eyJvIjoxMDB9", "total": 412 }
```
Treat the cursor as opaque. Pass it back exactly as you received it, with the same filters. A cursor from another list
is a `400 invalid_cursor`.
```python
import os
import requests
session = requests.Session()
session.headers.update({
"Authorization": f"Bearer {os.environ['OPENGRID_API_KEY']}",
"OpenGrid-Version": "2026-11-03",
})
def all_rows(path, **params):
cursor = None
while True:
r = session.get(f"https://data.tryopengrid.com{path}",
params={**params, "limit": 1000, "cursor": cursor}, timeout=60)
r.raise_for_status()
body = r.json()
yield from body["data"]
cursor = body["meta"].get("next_cursor")
if not cursor:
return
listings = list(all_rows("/v1/listings", gpu="nvidia-h100-80gb-sxm5"))
```
```js
async function* allRows(path, params = {}) {
let cursor = null;
do {
const q = new URLSearchParams({ ...params, limit: '1000', ...(cursor && { cursor }) });
const r = await fetch(`https://data.tryopengrid.com${path}?${q}`, {
headers: { Authorization: `Bearer ${process.env.OPENGRID_API_KEY}`, 'OpenGrid-Version': '2026-11-03' },
});
if (!r.ok) throw new Error((await r.json()).error.message);
const { data, meta } = await r.json();
yield* data;
cursor = meta.next_cursor;
} while (cursor);
}
for await (const row of allRows('/v1/listings', { gpu: 'nvidia-h100-80gb-sxm5' })) console.log(row.price_per_gpu_hour);
```
## Two kinds of cursor [#two-kinds-of-cursor]
- **Reference lists** (GPUs, providers, markets) are small and change slowly. Their cursor is a position in the list,
and `meta.total` is the full count.
- **Time-ordered feeds** (listing changes, capacity changes, events, news, fixings) are newest first. Their cursor
marks the last row you saw, so pages stay stable while new rows arrive.
To get everything for a past day in one file, use [bulk exports](/bulk-exports) instead.
# Point in time (/point-in-time)
`GET /v1/listings` accepts `as_of`, an ISO 8601 UTC time. It returns each public listing as it was last recorded at
or before that moment:
```bash
curl "https://data.tryopengrid.com/v1/listings?gpu=nvidia-h100-80gb-sxm5&as_of=2026-10-01T00:00:00Z" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
## What counts as live [#what-counts-as-live]
A listing is included if it had been seen by `as_of` and was still being seen then (within its last sighting plus a
few polls). This is the same rule the price charts use, so a point-in-time read agrees with history.
## What is and isn't historical [#what-is-and-isnt-historical]
- **Historical:** price, availability, capacity and observation time at that moment.
- **Current:** static fields such as region and specs.
- **Null:** `original` (currency conversion) and `trust`, which are not stored historically.
A future `as_of` is a `422`.
## Other ways to look back [#other-ways-to-look-back]
| You want | Use |
| --- | --- |
| A GPU's low, median and high over time | `GET /v1/markets/{gpu}/history` |
| Each provider's price line for a GPU | `GET /v1/markets/{gpu}/history/providers` |
| Every recorded change of a listing | `GET /v1/listings/history` |
| An index over time | `GET /v1/indices/{index}/history` |
| A whole past day, in one file | [Bulk exports](/bulk-exports) |
# Quickstart (/quickstart)
### Get an API key [#get-an-api-key]
Keys are issued by the OpenGrid team. Email with your company and what you want to build, and you will
get a key that starts with `opg_live_`.
Keep it out of source code. Store it in an environment variable:
```bash
export OPENGRID_API_KEY="opg_live_..."
```
### Make your first request [#make-your-first-request]
Ask for the current market of three GPUs:
```bash
curl "https://data.tryopengrid.com/v1/markets?limit=3" \
-H "Authorization: Bearer $OPENGRID_API_KEY" \
-H "OpenGrid-Version: 2026-11-03"
```
```python
import os
import requests
r = requests.get(
"https://data.tryopengrid.com/v1/markets",
params={"limit": 3},
headers={
"Authorization": f"Bearer {os.environ['OPENGRID_API_KEY']}",
"OpenGrid-Version": "2026-11-03",
},
timeout=30,
)
r.raise_for_status()
for row in r.json()["data"]:
print(row["gpu"], row["price"]["low"], row["price"]["median"])
```
```js
const r = await fetch('https://data.tryopengrid.com/v1/markets?limit=3', {
headers: {
Authorization: `Bearer ${process.env.OPENGRID_API_KEY}`,
'OpenGrid-Version': '2026-11-03',
},
});
if (!r.ok) throw new Error((await r.json()).error.message);
const { data } = await r.json();
for (const row of data) console.log(row.gpu, row.price.low, row.price.median);
```
### Read the response [#read-the-response]
Every success has the same envelope: your data in `data`, and request facts in `meta`.
```json
{
"data": [
{
"gpu": "nvidia-h100-80gb-sxm5",
"gpu_name": "NVIDIA H100 80GB SXM5",
"price": { "low": 1.6168, "median": 2.4216, "high": 2.9269, "currency": "USD", "unit": "gpu_hour" },
"low_provider": "vast",
"high_provider": "lambda",
"providers": 4,
"listings": { "live": 5, "priced": 4, "available": 4, "sold_out": 1, "availability_unknown": 0 },
"spread": { "abs": 1.3101, "pct_of_low": 0.810304, "pct_of_median": 0.541006 },
"score": { "efficiency": 69.1, "fragmentation": 30.9, "label": "moderately fragmented", "confidence": "low", "reason": null }
}
],
"meta": {
"as_of": "2026-11-06T14:00:00Z",
"api_version": "2026-11-03",
"request_id": "req_5bd092f30d380c07d2f32f8f",
"limit": 3,
"next_cursor": "eyJvIjozfQ",
"total": 41
}
}
```
Values above are illustrative. Prices are USD per GPU-hour, so you can compare across providers directly.
### Go further [#go-further]
- Get one GPU's price over time: `GET /v1/markets/nvidia-h100-80gb-sxm5/history?window=7d`.
- See every individual offer: `GET /v1/listings?gpu=nvidia-h100-80gb-sxm5`.
- Page through long lists with `cursor`. See [Pagination](/pagination).
## Try it in the browser [#try-it-in-the-browser]
Every page in the [API reference](/api-reference) has a playground. Paste your key into it, and requests go straight
from your browser to `data.tryopengrid.com`. Your key is stored only in your browser.
# Rate limits (/rate-limits)
Each key has a per-minute budget per request class. Each account also has a shared budget, so adding keys doesn't
multiply what an account can send. A request must fit both budgets.
| Class | Requests | Default per key | Default per account |
| --- | --- | --- | --- |
| `read` | `GET`, `HEAD` | 120 / min | 600 / min |
| `write` | other methods, such as `POST /v1/costs/estimate` | 30 / min | 120 / min |
Your agreement may set different limits. The headers are the source of truth for your key.
Budgets are token buckets. A full minute's budget can be spent in a burst, and it refills continuously.
## Headers [#headers]
Every authenticated response carries:
| Header | Meaning |
| --- | --- |
| `X-RateLimit-Limit` | Your budget per minute for this request class. |
| `X-RateLimit-Remaining` | Requests left in the bucket right now. |
| `X-RateLimit-Reset` | Seconds until the bucket is full again. |
| `X-RateLimit-Class` | `read` or `write`. |
## When you hit the limit [#when-you-hit-the-limit]
You get `429` with code `rate_limited` and a `Retry-After` header in seconds. Wait that long and retry.
```python
import time
import requests
def get(session, url, **kw):
for _ in range(5):
r = session.get(url, **kw)
if r.status_code != 429:
return r
time.sleep(int(r.headers.get("Retry-After", "1")))
return r
```
## Spending less [#spending-less]
- Use [conditional requests](/caching). A `304` still counts, but it carries no body.
- Use [bulk exports](/bulk-exports) for whole days of history instead of paging through feeds.
- Most data changes at the provider's polling interval (15 to 60 minutes). Polling the same route more often than
once a minute gets you the same data.
# Responses (/responses)
## Success [#success]
```json
{
"data": { "...": "the resource, or a list of them" },
"meta": {
"as_of": "2026-11-06T14:00:00Z",
"api_version": "2026-11-03",
"request_id": "req_5bd092f30d380c07d2f32f8f",
"next_cursor": null
}
}
```
| `meta` field | Meaning |
| --- | --- |
| `as_of` | When the response was built, UTC. Each row also carries its own observation time, such as `observed_at`. |
| `api_version` | The version the body is shaped for. See [Versioning](/versioning). |
| `request_id` | Unique per request. Quote it when you contact us. |
| `limit`, `next_cursor`, `total` | On lists. See [Pagination](/pagination). |
Some routes add context to `meta`, such as `methodology` (the document that defines the numbers) or `kind`
(`observed`, `estimated` or `inferred`).
## Errors [#errors]
Every error, including authentication and rate limits, has this shape:
```json
{
"error": {
"type": "invalid_request",
"code": "invalid_parameter",
"message": "window: Input should be '24h', '7d', '30d', '90d', 'ytd' or 'all'",
"param": "window",
"request_id": "req_b8f8cd7f553c12d68b341bb0",
"docs_url": "https://docs.tryopengrid.com/errors#invalid_parameter"
}
}
```
Branch on `code`, never on `message`. See [Errors](/errors) for every code.
## Headers [#headers]
| Header | On | Meaning |
| --- | --- | --- |
| `X-Request-Id` | every response | Same as `request_id`. |
| `OpenGrid-Version` | every response | The version used. |
| `X-RateLimit-Limit`, `-Remaining`, `-Reset` | every response | Your budget. See [Rate limits](/rate-limits). |
| `ETag`, `Cache-Control`, `Vary` | successful `GET`s | See [Caching](/caching). |
# Terms and support (/terms)
## Licence [#licence]
Data from the OpenGrid Data API is licensed for your **internal use** under your enterprise agreement. Don't
republish or resell it. Your agreement is the authoritative text. This page is a summary.
## Service [#service]
- **Freshness:** data is real time, as fresh as each provider's polling. Every row says when it was observed.
- **Availability:** the uptime commitment is set in your agreement.
- **Corrections** are always visible. See [Data rules](/data-rules#corrections).
- **Deprecation:** at least 12 months of support for a version after its successor ships, with 6 months' notice.
See [Versioning](/versioning#deprecation).
## Support [#support]
Email . Include the `request_id` from the response (also in the `X-Request-Id` header): it lets us find
your exact request.
# Versioning (/versioning)
The URL always starts with `/v1`. The shape of a response is chosen by a dated version, sent in the
`OpenGrid-Version` header:
```bash
curl https://data.tryopengrid.com/v1/markets \
-H "Authorization: Bearer $OPENGRID_API_KEY" \
-H "OpenGrid-Version: 2026-11-03"
```
## Which version you get [#which-version-you-get]
1. The `OpenGrid-Version` header, if you send one.
2. Otherwise, the version pinned to your key when it was created.
3. Otherwise, the latest version.
Every response says which version it was shaped for, in the `OpenGrid-Version` response header and in
`meta.api_version`.
An unknown or retired version is a `400` with code `unknown_api_version`, and the message lists the supported dates.
Send `OpenGrid-Version` on every request. Your integration then only changes shape when you change the header.
## Supported versions [#supported-versions]
| Version | Status |
| --- | --- |
| `2026-11-03` | Current |
## What changes without a new version [#what-changes-without-a-new-version]
These are additive, so they can ship at any time. Write your client to tolerate them:
- a new endpoint,
- a new field in a response,
- a new optional parameter,
- a new value in an enum field. Treat unknown values as "other", and don't fail on them.
## What needs a new version [#what-needs-a-new-version]
Removing or renaming a field, changing a type, unit or meaning, adding a required parameter, changing a default, or
changing an error `code`. Each one ships as a new dated version, and requests pinned to an older version keep the old
shape.
## Deprecation [#deprecation]
A version is supported for at least 12 months after its successor ships, with at least 6 months' notice by email
and in `Deprecation` and `Sunset` response headers. See the [changelog](/changelog).
# API reference (/api-reference)
```txt title="Base URL"
https://data.tryopengrid.com/v1
```
Each endpoint page lists its parameters and response fields, shows request examples in several languages, and has
a playground.
## The playground [#the-playground]
The playground calls the real API with **your** key. Paste it into the authorization field of any endpoint and
press **Send**. Requests go straight from your browser to `data.tryopengrid.com`, never through this site. Without
a key, every request returns `401`. Don't have a key? Email .
- Your key is stored only in this browser's local storage, so you don't need to paste it again on the next page.
Clear it from the authorization field when you're done on a shared machine.
- Requests count against your key's [rate limit](/rate-limits) like any other.
- This site may only send requests to `data.tryopengrid.com`. Its content security policy blocks every other
destination.
## Conventions [#conventions]
- Send `Authorization: Bearer opg_live_...` and, ideally, `OpenGrid-Version: 2026-11-03`. See
[Authentication](/authentication) and [Versioning](/versioning).
- Successes are `{"data": ..., "meta": ...}`, and errors are `{"error": {...}}`. See [Responses](/responses).
- Lists page by `cursor`. See [Pagination](/pagination).
## Machine-readable [#machine-readable]
The full schema is at [`/openapi.json`](/openapi.json). Generate a client from it, or give it to your agent. See
[For AI agents](/for-agents).
# List GPU families (/api-reference/reference/list-gpu-families)
## List GPU families
`GET https://data.tryopengrid.com/v1/families`
GPU families and their canonical variants.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `architecture` (null | string)
- `cheapest_variant_now` (null | object)
- `gpu` (string)
- `gpu_name` (string)
- `label` (string)
- `price_per_gpu_hour` (number)
- `provider` (string)
- `provider_name` (string)
- `id` (string)
- `kind` (string)
- `link` (string)
- `member_families` (array | null)
- `name` (string)
- `variants` (array of object)
- `gpu` (string)
- `gpu_name` (string)
- `price` (object)
- `providers` (number)
- `variants_priced` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/families" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a GPU family (/api-reference/reference/get-a-gpu-family)
## Get a GPU family
`GET https://data.tryopengrid.com/v1/families/{family}`
One GPU family: every variant side by side.
### Parameters
- `family` (path, required, string): GPU family id, e.g. `h100`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `architecture` (string)
- `cheapest_variant_now` (object)
- `gpu` (string)
- `gpu_name` (string)
- `label` (string)
- `price_per_gpu_hour` (number)
- `provider` (string)
- `provider_name` (string)
- `composite_index` (string)
- `id` (string)
- `kind` (string)
- `member_families` (null)
- `name` (string)
- `note` (string)
- `variants` (array of object)
- `gpu` (string)
- `gpu_name` (string)
- `index` (object)
- `links` (object)
- `listings` (object)
- `low_provider` (null | string)
- `price` (object)
- `providers` (number)
- `reason` (null | string)
- `variants_priced` (number)
- `variants_total` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/families/h100" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List GPUs (/api-reference/reference/list-gpus)
## List GPUs
`GET https://data.tryopengrid.com/v1/gpus`
Every canonical GPU: reference data and vendor specs.
### Parameters
- `vendor` (query, any)
- `family` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `architecture` (string)
- `bf16_tflops_dense` (null | number)
- `datacenter` (boolean)
- `families` (array of string)
- `form_factor` (null | string)
- `fp16_tflops_dense` (null | number)
- `fp32_tflops` (null | number)
- `fp8_supported` (boolean)
- `fp8_tflops_dense` (null | number)
- `fraction_of_parent` (number)
- `generation` (string)
- `id` (string)
- `interconnect` (null | string)
- `memory_bandwidth_tbps` (null | number)
- `memory_type` (null | string)
- `name` (string)
- `notes` (string)
- `nvlink` (null | string)
- `parent` (string)
- `released` (number)
- `segment` (string)
- `sources` (array of string)
- `tdp_w` (null | number)
- `vendor` (string)
- `vram_gb` (number)
- `workload_class` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/gpus" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a GPU (/api-reference/reference/get-a-gpu)
## Get a GPU
`GET https://data.tryopengrid.com/v1/gpus/{gpu}`
One GPU: reference data and vendor specs.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `architecture` (string)
- `bf16_tflops_dense` (number)
- `datacenter` (boolean)
- `families` (array of string)
- `form_factor` (string)
- `fp16_tflops_dense` (number)
- `fp32_tflops` (number)
- `fp8_supported` (boolean)
- `fp8_tflops_dense` (number)
- `generation` (string)
- `id` (string)
- `interconnect` (string)
- `memory_bandwidth_tbps` (number)
- `memory_type` (string)
- `name` (string)
- `notes` (string)
- `nvlink` (string)
- `released` (number)
- `segment` (string)
- `sources` (array of string)
- `tdp_w` (number)
- `vendor` (string)
- `vram_gb` (number)
- `workload_class` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/gpus/nvidia-h100-80gb-sxm5" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List providers (/api-reference/reference/list-providers)
## List providers
`GET https://data.tryopengrid.com/v1/providers`
Every provider: meta, coverage, relative value, feed health.
### Parameters
- `days` (query, integer)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `coverage` (object)
- `architectures` (array of string)
- `gpu_ids` (array of string)
- `gpus` (number)
- `listings` (object)
- `region_groups` (array of string)
- `facts` (array of string)
- `feed_health` (null | object)
- `avg_latency_ms_24h` (null)
- `failure_rate_24h` (number)
- `fetches_24h` (number)
- `last_fetch` (string)
- `last_ok_fetch` (string)
- `reason` (null)
- `listing_lifetime` (null | object)
- `label` (string)
- `listings` (number)
- `median_hours` (null | number)
- `reason` (null | string)
- `note` (string)
- `provider` (string)
- `provider_class` (string)
- `provider_name` (string)
- `relative_value` (null | object)
- `availability` (number)
- `cheapest_share` (number)
- `premium_avg` (number)
- `reasons` (object)
- `samples` (object)
- `top3_share` (number)
- `volatility_daily` (null | number)
- `source` (string)
- `source_type` (string)
- `website` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/providers" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a provider (/api-reference/reference/get-a-provider)
## Get a provider
`GET https://data.tryopengrid.com/v1/providers/{provider}`
One provider: catalog, pricing vs market, rank history, health.
### Parameters
- `provider` (path, required, string): Provider id, e.g. `lambda`.
- `days` (query, integer)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `beats_the_market` (array of object)
- `basis` (string)
- `gpu` (string)
- `gpu_name` (string)
- `premium` (number)
- `catalog` (array of object)
- `gpu` (string)
- `gpu_name` (string)
- `listings` (object)
- `market` (object)
- `premium_now` (null | number)
- `price_per_gpu_hour` (null | number)
- `rank_now` (null | number)
- `region_groups` (array of string)
- `window` (object)
- `coverage` (object)
- `architectures` (array of string)
- `gpu_ids` (array of string)
- `gpus` (number)
- `listings` (object)
- `region_groups` (array of string)
- `expensive` (array of object)
- `basis` (string)
- `gpu` (string)
- `gpu_name` (string)
- `premium` (number)
- `facts` (array of string)
- `feed_health` (object)
- `avg_latency_ms_24h` (null)
- `failure_rate_24h` (number)
- `fetches_24h` (number)
- `last_fetch` (string)
- `last_ok_fetch` (string)
- `reason` (null)
- `listing_lifetime` (object)
- `label` (string)
- `listings` (number)
- `median_hours` (number)
- `reason` (null)
- `note` (string)
- `provider` (string)
- `provider_class` (string)
- `provider_name` (string)
- `rank_distribution` (object)
- `rank_history` (array of object)
- `availability` (number)
- `cheapest_share` (null | number)
- `day` (string)
- `hours_compared` (number)
- `hours_market` (number)
- `mean_rank` (null | number)
- `premium_avg` (null | number)
- `top3_share` (null | number)
- `relative_value` (object)
- `availability` (number)
- `cheapest_share` (number)
- `premium_avg` (number)
- `reasons` (object)
- `samples` (object)
- `top3_share` (number)
- `volatility_daily` (number)
- `source` (string)
- `source_type` (string)
- `website` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/providers/lambda" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Provider price in context (/api-reference/reference/provider-price-in-context)
## Provider price in context
`GET https://data.tryopengrid.com/v1/providers/{provider}/gpus/{gpu}/context`
One provider's price for a GPU against its own recorded history.
### Parameters
- `provider` (path, required, string): Provider id, e.g. `lambda`.
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `segment` (query, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `current` (number)
- `gpu` (string)
- `gpu_name` (string)
- `historical` (object)
- `from_high_pct` (number)
- `from_low_pct` (number)
- `high` (object)
- `low` (object)
- `samples` (number)
- `since` (string)
- `hour` (string)
- `interruptible` (boolean)
- `label` (null)
- `label_reason` (string)
- `label_window` (null)
- `price_concept` (string)
- `provider` (string)
- `provider_name` (string)
- `reason` (null)
- `recorded_since` (string)
- `segment` (string)
- `summaries` (array of string)
- `vs_market_median_pct` (number)
- `windows` (object)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/providers/lambda/gpus/nvidia-h100-80gb-sxm5/context" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Listing price in context (/api-reference/reference/listing-price-in-context)
## Listing price in context
`GET https://data.tryopengrid.com/v1/providers/{provider}/listings/context`
One listing's price against its own recorded history (90 days).
### Parameters
- `provider` (path, required, string): Provider id, e.g. `lambda`.
- `listing_id` (query, required, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/providers/lambda/listings/context" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List region groups (/api-reference/reference/list-region-groups)
## List region groups
`GET https://data.tryopengrid.com/v1/regions`
Region groups and what is listed in each now.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `gpus` (number)
- `listings` (object)
- `live` (number)
- `priced` (number)
- `provider_ids` (array of string)
- `providers` (number)
- `region_group` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/regions" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List markets (/api-reference/markets/list-markets)
## List markets
`GET https://data.tryopengrid.com/v1/markets`
Current market per GPU: price, spread, efficiency score.
### Parameters
- `min_providers` (query, integer)
- `vendor` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `trend` (query, boolean): add change (lowest price over `hours`) and trend (a small series)
- `hours` (query, number): trend window; 0 = everything recorded
- `points` (query, integer): trend points
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `gpu` (string)
- `gpu_name` (string)
- `high_provider` (string)
- `listings` (object)
- `availability_unknown` (number)
- `available` (number)
- `live` (number)
- `priced` (number)
- `sold_out` (number)
- `low_provider` (string)
- `price` (object)
- `currency` (string)
- `high` (number)
- `low` (number)
- `median` (number)
- `unit` (string)
- `providers` (number)
- `score` (object)
- `confidence` (null | string)
- `efficiency` (null | number)
- `fragmentation` (null | number)
- `label` (null | string)
- `reason` (null | string)
- `spread` (object)
- `abs` (number)
- `pct_of_low` (number)
- `pct_of_median` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a market (/api-reference/markets/get-a-market)
## Get a market
`GET https://data.tryopengrid.com/v1/markets/{gpu}`
One GPU's market: price, stats, providers, capability, alternatives.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `alternatives` (object)
- `alternatives` (array of object)
- `gpu` (string)
- `gpu_name` (string)
- `note` (string)
- `target` (object)
- `by_provider` (array of object)
- `available` (boolean)
- `change_24h` (object)
- `listing_id` (string)
- `listings` (number)
- `premium_vs_others_median` (number)
- `price` (number)
- `provider` (string)
- `provider_name` (string)
- `rank` (number)
- `region` (null | string)
- `sku` (string)
- `capability` (object)
- `gpu` (string)
- `gpu_name` (string)
- `label` (string)
- `metrics` (object)
- `context` (object)
- `current` (object)
- `gpu` (string)
- `gpu_name` (string)
- `hour` (string)
- `interruptible` (boolean)
- `label` (null)
- `label_reason` (string)
- `label_window` (null)
- `metrics` (object)
- `price_concept` (string)
- `reason` (null)
- `segment` (string)
- `summaries` (array of string)
- `gpu` (string)
- `gpu_name` (string)
- `listings` (object)
- `availability_unknown` (number)
- `available` (number)
- `live` (number)
- `priced` (number)
- `sold_out` (number)
- `stats` (object)
- `price` (object)
- `currency` (string)
- `high` (number)
- `low` (number)
- `median` (number)
- `unit` (string)
- `providers` (number)
- `score` (object)
- `components` (object)
- `confidence` (string)
- `efficiency` (number)
- `fragmentation` (number)
- `label` (string)
- `reason` (null)
- `saturation` (object)
- `weights` (object)
- `stats` (object)
- `cv` (number)
- `high` (number)
- `iqr` (number)
- `iqr_rel` (number)
- `low` (number)
- `mean` (number)
- `median` (number)
- `n` (number)
- `q1` (number)
- `q3` (number)
- `reasons` (object)
- `spread_abs` (number)
- `spread_pct_of_low` (number)
- `spread_pct_of_median` (number)
- `stdev` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Market history (/api-reference/markets/market-history)
## Market history
`GET https://data.tryopengrid.com/v1/markets/{gpu}/history`
One GPU over time: low / median / high / provider count + index.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `window` (query, string)
- `interval` (query, any)
- `segment` (query, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `coherent_from` (string)
- `currency` (string)
- `gpu` (string)
- `gpu_name` (string)
- `index` (object)
- `index` (string)
- `points` (array of object)
- `interval` (string)
- `latest_hour` (string)
- `providers_joined` (array of object)
- `first_hour` (string)
- `provider` (string)
- `provider_name` (string)
- `segment` (string)
- `series` (array of object)
- `high` (number)
- `low` (number)
- `median` (number)
- `providers` (number)
- `t` (string)
- `unit` (string)
- `window` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/history" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Archived price history (/api-reference/markets/archived-price-history)
## Archived price history
`GET https://data.tryopengrid.com/v1/markets/{gpu}/history/archived`
One GPU's ARCHIVED price history: public archive captures of provider price pages.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `segment` (query, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `gpu` (string)
- `gpu_name` (string)
- `kind` (string)
- `monthly` (array)
- `observed_from` (string)
- `points` (array)
- `providers` (array)
- `segment` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/history/archived" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Daily market history (/api-reference/markets/daily-market-history)
## Daily market history
`GET https://data.tryopengrid.com/v1/markets/{gpu}/history/daily`
One GPU, daily, as far back as archives reach: archived before recording, observed after.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `days` (query, integer): 0 = everything archived
- `segment` (query, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `archived_until` (string)
- `days` (array of string)
- `gpu` (string)
- `gpu_name` (string)
- `hold_days` (number)
- `kind` (array of string)
- `market` (object)
- `high` (array of null | number)
- `low` (array of null | number)
- `median` (array of null | number)
- `providers` (array of number)
- `providers` (array of object)
- `capture` (array of null)
- `captures` (array)
- `provider` (string)
- `provider_name` (string)
- `values` (array of null | number)
- `resolution` (string)
- `segment` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/history/daily" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Price dispersion history (/api-reference/markets/price-dispersion-history)
## Price dispersion history
`GET https://data.tryopengrid.com/v1/markets/{gpu}/history/dispersion`
Dispersion of one GPU over time.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `days` (query, integer)
- `interval` (query, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `days` (number)
- `gpu` (string)
- `gpu_name` (string)
- `interval` (string)
- `note` (string)
- `points` (array of object)
- `close_high` (number)
- `close_low` (number)
- `close_median` (number)
- `close_providers` (number)
- `cv_hours` (number)
- `cv_mean` (null | number)
- `hours_market` (number)
- `iqr_rel_mean` (null | number)
- `providers_max` (number)
- `spread_pct_of_low_mean` (null | number)
- `t` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/history/dispersion" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Price history by provider (/api-reference/markets/price-history-by-provider)
## Price history by provider
`GET https://data.tryopengrid.com/v1/markets/{gpu}/history/providers`
Each provider's price over time for one GPU, with the market low / median / high.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `hours` (query, number): 0 = everything recorded
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `change_pct` (number)
- `change_since` (string)
- `gpu` (string)
- `gpu_name` (string)
- `high` (array of number)
- `hours` (number)
- `low` (array of number)
- `market_from` (string)
- `median` (array of number)
- `providers` (array of object)
- `available` (boolean | null)
- `change_pct` (null | number)
- `first_seen` (string)
- `gpu_count` (null | number)
- `now` (null | number)
- `provider` (string)
- `provider_name` (string)
- `region` (null | string)
- `series` (array of null | number)
- `sku` (null | string)
- `t0` (string)
- `t1` (string)
- `times` (array of string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/history/providers" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Market by region (/api-reference/markets/market-by-region)
## Market by region
`GET https://data.tryopengrid.com/v1/markets/{gpu}/regions`
One GPU by region group: cheapest, median, providers, premium.
### Parameters
- `gpu` (path, required, string): GPU id, e.g. `nvidia-h100-80gb-sxm5`. Older short names (`h100-80gb-sxm5`) are accepted as aliases; responses always return the id.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `global` (object)
- `price` (object)
- `providers` (number)
- `gpu` (string)
- `gpu_name` (string)
- `regions` (array of object)
- `listings` (object)
- `low_provider` (null | string)
- `premium_vs_global_median` (null | number)
- `price` (object)
- `provider_ids` (array of string)
- `providers` (number)
- `reason` (null | string)
- `region_group` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/markets/nvidia-h100-80gb-sxm5/regions" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List listings (/api-reference/listings/list-listings)
## List listings
`GET https://data.tryopengrid.com/v1/listings`
Current price listings: every offer, cheapest first, with provenance.
### Parameters
- `gpu` (query, any)
- `provider` (query, any)
- `region_group` (query, any)
- `market_type` (query, any)
- `available` (query, any)
- `as_of` (query, any): the listings as published at this time (UTC)
- `previous` (query, boolean): add price_change: the price before the newest recorded change
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `available` (boolean)
- `capacity` (null)
- `capacity_unit` (null)
- `country` (null | string)
- `currency` (string)
- `first_seen_at` (string)
- `gpu` (string)
- `gpu_count` (number)
- `gpu_name` (string)
- `interruptible` (boolean)
- `listing_id` (string)
- `market_type` (string)
- `observed_at` (string)
- `original` (null)
- `price_change` (null)
- `price_per_gpu_hour` (number)
- `price_per_instance_hour` (number)
- `provider` (string)
- `provider_name` (string)
- `provider_tier` (null)
- `ram_gb` (null)
- `raw_gpu_name` (string)
- `region` (null | string)
- `region_group` (string)
- `sku` (string)
- `storage_gb` (null)
- `trust` (object)
- `age_seconds` (number)
- `availability_basis` (string)
- `confidence` (string)
- `confidence_reasons` (array of string)
- `flags` (array)
- `freshness` (string)
- `held` (array)
- `last_changed` (string)
- `last_fetched` (string)
- `last_seen` (string)
- `polling_interval_seconds` (number)
- `provider_status` (string)
- `source` (null)
- `source_detail` (string)
- `source_type` (string)
- `vcpu` (null)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/listings" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Listing changes (/api-reference/listings/listing-changes)
## Listing changes
`GET https://data.tryopengrid.com/v1/listings/history`
Recorded listing changes (price, availability, capacity), newest first.
### Parameters
- `gpu` (query, any)
- `provider` (query, any)
- `listing_id` (query, any)
- `from` (query, any)
- `to` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `available` (boolean)
- `capacity` (null)
- `capacity_unit` (null)
- `gpu` (string)
- `gpu_count` (number)
- `gpu_name` (string)
- `listing_id` (string)
- `market_type` (string)
- `observed_at` (string)
- `price_per_gpu_hour` (number)
- `price_per_instance_hour` (number)
- `provider` (string)
- `provider_name` (string)
- `region` (null | string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/listings/history" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List reserved prices (/api-reference/reserved/list-reserved-prices)
## List reserved prices
`GET https://data.tryopengrid.com/v1/reserved`
Reserved and committed GPU prices, with the on-demand saving.
### Parameters
- `gpu` (query, any): GPU slug or canonical name
- `provider` (query, any)
- `term` (query, any): term bucket: lt1m, 1m, 3m, 6m, 1y, 2y, 3y, 5y
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reserved" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Reserved price summary (/api-reference/reserved/reserved-price-summary)
## Reserved price summary
`GET https://data.tryopengrid.com/v1/reserved/summary`
Per GPU: the cheapest reserved price in each term.
### Parameters
- `gpu` (query, any): GPU slug or canonical name
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reserved/summary" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List indices (/api-reference/indices/list-indices)
## List indices
`GET https://data.tryopengrid.com/v1/indices`
OpenGrid indices: current level and changes.
### Parameters
- `kind` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `change_reasons` (object)
- `all` (string)
- `ytd` (string)
- `changes` (object)
- `all` (null | number)
- `ytd` (null)
- `constituents` (number)
- `coverage` (object)
- `chain_segment` (null | number)
- `chain_segment_start` (null | string)
- `constituents_now` (number)
- `first_published` (null | string)
- `hours_30d` (number)
- `published_hours_30d` (number)
- `first_published` (null | string)
- `gpu` (null | string)
- `gpu_name` (string)
- `high` (null | object)
- `hour` (string)
- `level` (number)
- `since` (string)
- `hour` (string)
- `id` (string)
- `interruptible` (boolean)
- `kind` (string)
- `last_published` (null | object)
- `hour` (string)
- `level` (number)
- `level` (null | number)
- `low` (null | object)
- `hour` (string)
- `level` (number)
- `since` (string)
- `name` (string)
- `provider_class` (null)
- `published` (boolean)
- `raw_level` (null | number)
- `reason` (null | string)
- `region_group` (null | string)
- `segment` (string)
- `spark_7d` (array of null | number)
- `unit` (string)
- `volatility` (object)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/indices" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get an index (/api-reference/indices/get-an-index)
## Get an index
`GET https://data.tryopengrid.com/v1/indices/{index_id}`
One index: definition, level, constituents, statistics.
### Parameters
- `index_id` (path, required, string): Index id, e.g. `h100-80gb-sxm5` (index ids are frozen, see IDs).
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `changes` (object)
- `all` (object)
- `ytd` (object)
- `components` (array)
- `constituents` (number)
- `constituents_now` (object)
- `constituents` (array of object)
- `hour` (string)
- `coverage` (object)
- `chain_segment` (number)
- `chain_segment_start` (string)
- `constituents_now` (number)
- `first_published` (string)
- `hours_30d` (number)
- `published_hours_30d` (number)
- `description` (string)
- `gpu` (string)
- `gpu_name` (string)
- `high` (object)
- `hour` (string)
- `level` (number)
- `since` (string)
- `hour` (string)
- `id` (string)
- `interruptible` (boolean)
- `kind` (string)
- `last_published` (object)
- `hour` (string)
- `level` (number)
- `level` (number)
- `low` (object)
- `hour` (string)
- `level` (number)
- `since` (string)
- `method` (string)
- `methodology` (string)
- `methodology_version` (string)
- `name` (string)
- `note` (null)
- `price_concept` (string)
- `provider_class` (null)
- `published` (boolean)
- `raw_level` (number)
- `reason` (null)
- `region_group` (null)
- `segment` (string)
- `spark_7d` (array of null | number)
- `unit` (string)
- `volatility` (object)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/indices/h100-80gb-sxm5" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Index fixings (/api-reference/indices/index-fixings)
## Index fixings
`GET https://data.tryopengrid.com/v1/indices/{index_id}/fixings`
Official fixing history of one index.
### Parameters
- `index_id` (path, required, string): Index id, e.g. `h100-80gb-sxm5` (index ids are frozen, see IDs).
- `type` (query, any)
- `status` (query, any)
- `from` (query, any)
- `to` (query, any)
- `effective` (query, boolean)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `fixings` (array)
- `index` (string)
- `index_name` (string)
- `settlement_index` (boolean)
- `unit` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/indices/h100-80gb-sxm5/fixings" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Index history (/api-reference/indices/index-history)
## Index history
`GET https://data.tryopengrid.com/v1/indices/{index_id}/history`
Stored index levels over a window.
### Parameters
- `index_id` (path, required, string): Index id, e.g. `h100-80gb-sxm5` (index ids are frozen, see IDs).
- `window` (query, string)
- `interval` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `index` (string)
- `index_name` (string)
- `interval` (string)
- `points` (array of object)
- `constituents` (number)
- `level` (null | number)
- `link_constituents` (null | number)
- `published` (boolean)
- `raw_level` (number)
- `reason` (null | string)
- `segment_no` (null | number)
- `t` (string)
- `unit` (string)
- `window` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/indices/h100-80gb-sxm5/history" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List latest fixings (/api-reference/fixings/list-latest-fixings)
## List latest fixings
`GET https://data.tryopengrid.com/v1/fixings`
Latest official fixings of every settlement index.
### Parameters
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `final_through` (string)
- `indices` (array of object)
- `daily` (null)
- `hourly` (null)
- `index` (string)
- `index_name` (string)
- `provisional` (object)
- `unit` (string)
- `ledger_head` (null)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fixings" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Verify the fixing chain (/api-reference/fixings/verify-the-fixing-chain)
## Verify the fixing chain
`GET https://data.tryopengrid.com/v1/fixings/chain/verify`
Check the hash chain over the whole fixings ledger (paged).
### Parameters
- `from_seq` (query, any)
- `limit` (query, integer)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `break_count` (number)
- `breaks` (array)
- `checked` (number)
- `from_seq` (null)
- `head_hash` (string)
- `head_seq` (null)
- `ledger_rows` (number)
- `next_seq` (null)
- `ok` (boolean)
- `result` (string)
- `to_seq` (null)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fixings/chain/verify" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Fixing methodology (/api-reference/fixings/fixing-methodology)
## Fixing methodology
`GET https://data.tryopengrid.com/v1/fixings/methodology`
Fixing schedule, thresholds, correction windows, change notices.
### Parameters
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `correction_windows` (object)
- `daily_business_days` (number)
- `hourly_hours` (number)
- `daily` (object)
- `fixing_time` (string)
- `hours` (number)
- `min_hours` (number)
- `statistic` (string)
- `hourly` (object)
- `fixing_time` (string)
- `rollup_overlap_hours` (number)
- `safety_margin_hours` (number)
- `taken_after` (string)
- `index_methodology_version` (string)
- `notices` (array)
- `settlement_indices` (array of string)
- `settlement_version` (string)
- `sufficiency` (object)
- `min_components` (number)
- `min_constituents` (number)
- `surveillance` (object)
- `concentration_severe` (number)
- `concentration_warn` (number)
- `feed_outage_severe_share` (number)
- `jump_pct` (number)
- `new_listing_hours` (number)
- `pre_fix_hours` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fixings/methodology" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List restatements (/api-reference/fixings/list-restatements)
## List restatements
`GET https://data.tryopengrid.com/v1/fixings/restatements`
Every restatement: what was corrected, by whom, why.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fixings/restatements" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a fixing (/api-reference/fixings/get-a-fixing)
## Get a fixing
`GET https://data.tryopengrid.com/v1/fixings/{fixing_id}`
One fixing: value, flags, full inputs and raw evidence.
### Parameters
- `fixing_id` (path, required, string): Fixing id, as returned by `GET /v1/fixings`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fixings/{fixing_id}" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Verify a fixing (/api-reference/fixings/verify-a-fixing)
## Verify a fixing
`GET https://data.tryopengrid.com/v1/fixings/{fixing_id}/verify`
Recompute a fixing from its stored inputs; check hashes and links.
### Parameters
- `fixing_id` (path, required, string): Fixing id, as returned by `GET /v1/fixings`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `break_count` (number)
- `breaks` (array)
- `checked` (number)
- `from_seq` (null)
- `head_hash` (string)
- `head_seq` (null)
- `ledger_rows` (number)
- `next_seq` (null)
- `ok` (boolean)
- `result` (string)
- `to_seq` (null)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fixings/{fixing_id}/verify" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List capacity (/api-reference/capacity/list-capacity)
## List capacity
`GET https://data.tryopengrid.com/v1/capacity`
Provider-reported capacity, by SKU and region.
### Parameters
- `gpu` (query, any): GPU slug or canonical name
- `provider` (query, any)
- `in_stock` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/capacity" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Capacity changes (/api-reference/capacity/capacity-changes)
## Capacity changes
`GET https://data.tryopengrid.com/v1/capacity/history`
Capacity state changes, newest first.
### Parameters
- `gpu` (query, any)
- `provider` (query, any)
- `sku` (query, any)
- `region` (query, any)
- `days` (query, integer)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/capacity/history" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Billing increments (/api-reference/costs/billing-increments)
## Billing increments
`GET https://data.tryopengrid.com/v1/costs/billing`
Billing increment and minimum per provider.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `increment_s` (null | number)
- `minimum_s` (null | number)
- `notes` (null | string)
- `products` (null | object)
- `provider` (string)
- `provider_name` (string)
- `source` (string)
- `status` (string)
- `verified_at` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/costs/billing" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Cost components (/api-reference/costs/cost-components)
## Cost components
`GET https://data.tryopengrid.com/v1/costs/components`
Egress, storage and other cost components per provider.
### Parameters
- `provider` (query, any)
- `component` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `allowance_scope` (null | string)
- `as_of` (string)
- `billed_when_stopped` (boolean | null)
- `component` (string)
- `kind` (string)
- `listing_id` (null)
- `notes` (null | string)
- `origin` (string)
- `product` (string)
- `provider` (string)
- `provider_name` (string)
- `raw_unit` (string)
- `region` (null | string)
- `source` (string)
- `status` (string)
- `tiers` (array of object)
- `end_gb` (null | number)
- `price` (number)
- `start_gb` (number)
- `unit` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/costs/components" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Estimate a job's cost (/api-reference/costs/estimate-a-job-s-cost)
## Estimate a job's cost
`POST https://data.tryopengrid.com/v1/costs/estimate`
Full cost of a job per provider: compute + egress + storage, unknown components named.
### Parameters
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Request body (JSON)
- `preset` (string): A reference job (`GET /v1/costs/presets`).
- `gpu` (string): GPU id or alias.
- `count` (integer)
- `hours` (number)
- `egress_tb` (number): Give `egress_tb` or `egress_gb`, not both.
- `egress_gb` (number)
- `storage_tb` (number): Give `storage_tb` or `storage_gb`, not both.
- `storage_gb` (number)
- `storage_class` (string)
- `min_fabric_gbps` (number): Only providers whose interconnect is at least this fast.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl -X POST "https://data.tryopengrid.com/v1/costs/estimate" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Reference jobs (/api-reference/costs/reference-jobs)
## Reference jobs
`GET https://data.tryopengrid.com/v1/costs/presets`
The published reference jobs.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `count` (number)
- `egress_gb` (number)
- `gpu` (string)
- `gpu_name` (string)
- `hours` (number)
- `label` (string)
- `preset` (string)
- `storage_gb` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/costs/presets" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Cost sources (/api-reference/costs/cost-sources)
## Cost sources
`GET https://data.tryopengrid.com/v1/costs/sources`
Machine-readable cost sources and their last fetch.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `description` (string)
- `last_attempt_at` (null)
- `last_attempt_ok` (null)
- `last_error` (null)
- `last_ok_fetch_at` (null)
- `provider` (string)
- `provider_name` (string)
- `source` (string)
- `url` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/costs/sources" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Current FX rates (/api-reference/fx/current-fx-rates)
## Current FX rates
`GET https://data.tryopengrid.com/v1/fx/rates`
Reference rates in force now: EUR->USD and every X->USD cross.
### Parameters
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `eur_usd` (object)
- `age_days` (null)
- `base` (string)
- `cross_currencies` (array)
- `cross_method` (string)
- `last_fetch_at` (null)
- `last_fetch_error` (null)
- `last_fetch_ok` (null)
- `last_ok_fetch_at` (null)
- `max_age_days` (number)
- `published_at` (null)
- `quote` (string)
- `rate` (null)
- `rate_date` (null)
- `source` (string)
- `source_name` (string)
- `source_url` (string)
- `state` (string)
- `to_usd` (array)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fx/rates" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# FX rate history (/api-reference/fx/fx-rate-history)
## FX rate history
`GET https://data.tryopengrid.com/v1/fx/rates/history`
Stored ECB EUR->X reference rates (default USD), newest first.
### Parameters
- `days` (query, integer)
- `quote` (query, string)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/fx/rates/history" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Probe vantage points (/api-reference/reliability/probe-vantage-points)
## Probe vantage points
`GET https://data.tryopengrid.com/v1/reliability/agents`
Vantage points that have reported.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/agents" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Provider incidents (/api-reference/reliability/provider-incidents)
## Provider incidents
`GET https://data.tryopengrid.com/v1/reliability/incidents`
Incidents providers reported on their own status pages.
### Parameters
- `provider` (query, any)
- `days` (query, integer)
- `scope` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/incidents" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Raw probe results (/api-reference/reliability/raw-probe-results)
## Raw probe results
`GET https://data.tryopengrid.com/v1/reliability/probes`
Raw probe results of one target, newest first.
### Parameters
- `target` (query, required, string)
- `location` (query, any)
- `limit` (query, integer)
- `failures_only` (query, boolean)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/probes" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Provider reliability (/api-reference/reliability/provider-reliability)
## Provider reliability
`GET https://data.tryopengrid.com/v1/reliability/providers`
Per provider: probe status, availability, latency; data freshness; feed health.
### Parameters
- `hours` (query, integer)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `feed_health` (null | object)
- `consecutive_failures` (number)
- `display_name` (string)
- `failure_rate_24h` (number)
- `failures_24h` (number)
- `fetches_24h` (number)
- `last_failure_at` (null)
- `last_ok_fetch` (string)
- `latency_ms_p50_24h` (null)
- `latency_ms_p95_24h` (null)
- `listings_24h_ago` (null)
- `listings_24h_ago_at` (null)
- `listings_24h_ago_note` (string)
- `listings_now` (number)
- `listings_total` (number)
- `polling_interval_seconds` (number)
- `quarantined` (number)
- `schema_changes_24h` (number)
- `schema_changes_7d` (number)
- `source` (string)
- `source_type` (string)
- `status` (string)
- `status_reasons` (array)
- `throttled_24h` (number)
- `freshness` (array)
- `probes` (null | object)
- `availability` (null)
- `kinds` (array of string)
- `latency_p50_ms` (null)
- `locations` (array)
- `source` (string)
- `status` (string)
- `targets` (array of object)
- `provider` (string)
- `provider_name` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/providers" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# One provider's reliability (/api-reference/reliability/one-provider-s-reliability)
## One provider's reliability
`GET https://data.tryopengrid.com/v1/reliability/providers/{provider}`
One provider: probes with each target's series, data freshness, feed health.
### Parameters
- `provider` (path, required, string): Provider id, e.g. `lambda`.
- `hours` (query, integer)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `feed_health` (object)
- `consecutive_failures` (number)
- `display_name` (string)
- `failure_rate_24h` (number)
- `failures_24h` (number)
- `fetches_24h` (number)
- `last_failure_at` (null)
- `last_ok_fetch` (string)
- `latency_ms_p50_24h` (null)
- `latency_ms_p95_24h` (null)
- `listings_24h_ago` (null)
- `listings_24h_ago_at` (null)
- `listings_24h_ago_note` (string)
- `listings_now` (number)
- `listings_total` (number)
- `polling_interval_seconds` (number)
- `quarantined` (number)
- `schema_changes_24h` (number)
- `schema_changes_7d` (number)
- `source` (string)
- `source_type` (string)
- `status` (string)
- `status_reasons` (array)
- `throttled_24h` (number)
- `freshness` (array)
- `probes` (null)
- `provider` (string)
- `provider_name` (string)
- `targets` (array)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/providers/lambda" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Reliability dips (/api-reference/reliability/reliability-dips)
## Reliability dips
`GET https://data.tryopengrid.com/v1/reliability/providers/{provider}/dips`
Hours with a failed check, with measured scope and reason.
### Parameters
- `provider` (path, required, string): Provider id, e.g. `lambda`.
- `days` (query, integer)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/providers/lambda/dips" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Probe targets (/api-reference/reliability/probe-targets)
## Probe targets
`GET https://data.tryopengrid.com/v1/reliability/targets`
What OpenGrid probes.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `accept` (array of number)
- `id` (string)
- `interval_s` (number)
- `kind` (string)
- `name` (string)
- `note` (string)
- `provider` (string)
- `provider_name` (string)
- `region` (null | string)
- `url` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/reliability/targets" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List events (/api-reference/events/list-events)
## List events
`GET https://data.tryopengrid.com/v1/events`
Market events, newest first.
### Parameters
- `gpu` (query, any): GPU slug or canonical name
- `provider` (query, any)
- `type` (query, any): comma-separated event types
- `severity` (query, any): comma-separated: info, notable, major
- `min_severity` (query, any)
- `since` (query, any)
- `until` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `dedupe_key` (string)
- `detail` (object)
- `basis` (string)
- `direction` (string)
- `examples` (array of object)
- `from` (number)
- `gpus` (number)
- `is_cheapest` (boolean)
- `last_lowest` (number)
- `last_price` (number)
- `listings` (number)
- `live_markets` (number)
- `lowest` (number)
- `lowest_provider` (string)
- `markets` (number)
- `matched` (boolean)
- `median` (number)
- `metric` (string)
- `previous_price` (number)
- `previous_provider` (string)
- `previous_provider_now` (null | number)
- `price` (number)
- `priced_listings` (number)
- `providers` (array | number)
- `reason` (string)
- `share` (number)
- `since` (string)
- `sold_out_listings` (number)
- `to` (number)
- `was_cheapest` (boolean)
- `detected_at` (string)
- `gpu` (null | string)
- `gpu_name` (string)
- `id` (number)
- `kind` (string)
- `occurred_at` (string)
- `pct` (null | number)
- `provider` (null | string)
- `provider_name` (null | string)
- `region_group` (null)
- `segment` (string)
- `severity` (string)
- `title` (string)
- `type` (string)
- `value_after` (null | number)
- `value_before` (null | number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/events" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List shifts (/api-reference/events/list-shifts)
## List shifts
`GET https://data.tryopengrid.com/v1/events/shifts`
Major market shifts with related items (not necessarily causal).
### Parameters
- `gpu` (query, any): GPU slug or canonical name
- `provider` (query, any)
- `kind` (query, any)
- `type` (query, any): comma-separated shift types; see /v1/events/shifts/definition
- `severity` (query, any)
- `since` (query, any)
- `until` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `top` (query, integer): related items per shift in the list
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/events/shifts" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Shift definition (/api-reference/events/shift-definition)
## Shift definition
`GET https://data.tryopengrid.com/v1/events/shifts/definition`
How a major shift is defined and its items ranked.
### Parameters
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `heading` (string)
- `items_version` (string)
- `note` (string)
- `ranking` (string)
- `segment` (string)
- `thresholds` (object)
- `archived_min` (number)
- `baseline_days` (number)
- `baseline_min_hours` (number)
- `index_min` (number)
- `k_times_rms` (number)
- `major` (string)
- `median_min` (number)
- `median_min_providers` (number)
- `reprice_min_gpus` (number)
- `types` (object)
- `archived_price_change` (object)
- `archived_provider_repricing` (object)
- `capacity_collapse` (object)
- `index_move` (object)
- `market_median` (object)
- `provider_repricing` (object)
- `version` (string)
- `window` (object)
- `after_hours` (number)
- `archived_pad_days` (number)
- `before_hours` (number)
- `max_items` (number)
- `settle_days` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/events/shifts/definition" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a shift (/api-reference/events/get-a-shift)
## Get a shift
`GET https://data.tryopengrid.com/v1/events/shifts/{shift_id}`
One shift with every related item (not necessarily causal).
### Parameters
- `shift_id` (path, required, integer): Shift id, as returned by `GET /v1/events/shifts`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `heading` (string)
- `items_version` (string)
- `note` (string)
- `ranking` (string)
- `segment` (string)
- `thresholds` (object)
- `archived_min` (number)
- `baseline_days` (number)
- `baseline_min_hours` (number)
- `index_min` (number)
- `k_times_rms` (number)
- `major` (string)
- `median_min` (number)
- `median_min_providers` (number)
- `reprice_min_gpus` (number)
- `types` (object)
- `archived_price_change` (object)
- `archived_provider_repricing` (object)
- `capacity_collapse` (object)
- `index_move` (object)
- `market_median` (object)
- `provider_repricing` (object)
- `version` (string)
- `window` (object)
- `after_hours` (number)
- `archived_pad_days` (number)
- `before_hours` (number)
- `max_items` (number)
- `settle_days` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/events/shifts/{shift_id}" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Event types (/api-reference/events/event-types)
## Event types
`GET https://data.tryopengrid.com/v1/events/types`
Event catalogue: triggers, severity rules, data kind.
### Parameters
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `events` (array of object)
- `description` (string)
- `kind` (string)
- `severity` (string)
- `type` (string)
- `opportunities` (array of object)
- `description` (string)
- `kind` (string)
- `type` (string)
- `severities` (array of string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/events/types" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List news (/api-reference/news/list-news)
## List news
`GET https://data.tryopengrid.com/v1/news`
GPU market news clustered into stories, newest activity first. Filter by GPU, provider, region, topic, source or free text (`q`).
### Parameters
- `gpu` (query, any)
- `provider` (query, any)
- `region` (query, any)
- `topic` (query, any)
- `source` (query, any)
- `q` (query, any)
- `since` (query, any)
- `min_relevance` (query, integer)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/news" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# News GPU families (/api-reference/news/news-gpu-families)
## News GPU families
`GET https://data.tryopengrid.com/v1/news/families`
Every GPU family the news classifier recognises; `tracked: false` means OpenGrid has no prices for it.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `architecture` (null | string)
- `id` (string)
- `kind` (string)
- `member_families` (array | null)
- `name` (string)
- `slug` (string)
- `tracked` (boolean)
- `variants` (array of string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/news/families" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# News sources (/api-reference/news/news-sources)
## News sources
`GET https://data.tryopengrid.com/v1/news/sources`
Every news source OpenGrid reads, with its health.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `avg_fetch_ms_24h` (null)
- `backfilled_items` (number)
- `category` (string)
- `conditional_get` (boolean)
- `consecutive_failures` (number)
- `day_dates` (boolean)
- `enabled` (boolean)
- `entity_hints` (object)
- `provider` (string)
- `provider_name` (string)
- `vendor` (string)
- `fetches_24h` (number)
- `health` (string)
- `id` (string)
- `items_stored` (number)
- `key` (string)
- `kind` (string)
- `last_error` (null)
- `last_fetched_at` (null)
- `last_ok_at` (null)
- `name` (string)
- `new_items_24h` (number)
- `newest_item_at` (null)
- `note` (string)
- `ok_fetches_24h` (number)
- `oldest_dated_item_at` (null)
- `poll_seconds` (number)
- `topics` (array of string)
- `trust_tier` (string)
- `url` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/news/sources" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# News topics (/api-reference/news/news-topics)
## News topics
`GET https://data.tryopengrid.com/v1/news/topics`
The topic catalogue, with how many items each had in the last 30 days.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `description` (string)
- `id` (string)
- `items_30d` (number)
- `weight` (number)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/news/topics" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a news story (/api-reference/news/get-a-news-story)
## Get a news story
`GET https://data.tryopengrid.com/v1/news/{item_id}`
One news item with its classification (topics, GPUs, providers it concerns).
### Parameters
- `item_id` (path, required, integer): News story id, as returned by `GET /v1/news`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/news/{item_id}" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Timeline (/api-reference/news/timeline)
## Timeline
`GET https://data.tryopengrid.com/v1/timeline`
Price moves, events and news for a GPU and/or provider over a window, on one timeline. Give `gpu`, `provider` or both.
### Parameters
- `gpu` (query, any)
- `provider` (query, any)
- `window` (query, string)
- `end` (query, any)
- `segment` (query, string)
- `move_pct` (query, number)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/timeline" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Timeline around a moment (/api-reference/news/timeline-around-a-moment)
## Timeline around a moment
`GET https://data.tryopengrid.com/v1/timeline/around`
What happened around one moment (`at`) for a GPU: the price move, events and news within `window_hours`. Shown together, not claimed as cause and effect.
### Parameters
- `gpu` (query, required, string)
- `at` (query, required, string)
- `window_hours` (query, number)
- `provider` (query, any)
- `segment` (query, string)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/timeline/around" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Listings beside power prices (/api-reference/macro/listings-beside-power-prices)
## Listings beside power prices
`GET https://data.tryopengrid.com/v1/macro/power`
US listings by state, beside the state's electricity price.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
See the Responses page for the envelope.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/macro/power" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List macro series (/api-reference/macro/list-macro-series)
## List macro series
`GET https://data.tryopengrid.com/v1/macro/series`
Market-context series: the catalogue.
### Parameters
- `source` (query, any)
- `entity` (query, any)
- `geo` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `attribution` (string)
- `enabled` (boolean)
- `entity` (null)
- `frequency` (string)
- `geo` (string)
- `latest` (null)
- `market_area` (null | string)
- `name` (string)
- `points` (number)
- `series_id` (string)
- `source` (string)
- `unit` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/macro/series" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a macro series (/api-reference/macro/get-a-macro-series)
## Get a macro series
`GET https://data.tryopengrid.com/v1/macro/series/{series}`
One market-context series: source, unit, latest.
### Parameters
- `series` (path, required, string): Series id, as returned by `GET /v1/macro/series`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/macro/series/{series}" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Macro series history (/api-reference/macro/macro-series-history)
## Macro series history
`GET https://data.tryopengrid.com/v1/macro/series/{series}/history`
One market-context series over time.
### Parameters
- `series` (path, required, string): Series id, as returned by `GET /v1/macro/series`.
- `since` (query, any)
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/macro/series/{series}/history" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List methodology documents (/api-reference/methodology/list-methodology-documents)
## List methodology documents
`GET https://data.tryopengrid.com/v1/methodology`
Methodology documents: name, title, links.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `html` (string)
- `markdown` (string)
- `name` (string)
- `summary` (string)
- `title` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/methodology" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Get a methodology document (/api-reference/methodology/get-a-methodology-document)
## Get a methodology document
`GET https://data.tryopengrid.com/v1/methodology/{name}`
One methodology document as raw markdown.
### Parameters
- `name` (path, required, string): Methodology document name, e.g. `indices`.
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
Field-level schema not published for this route yet; send a request to see one.
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/methodology/indices" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# List export datasets (/api-reference/bulk-exports/list-export-datasets)
## List export datasets
`GET https://data.tryopengrid.com/v1/exports`
Bulk export datasets and the first day each has data.
### Parameters
- `limit` (query, integer)
- `cursor` (query, any)
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response `data`
- `dataset` (string)
- `description` (string)
- `first_date` (null | string)
- `format` (string)
- `url` (string)
Every success is `{"data": ..., "meta": {as_of, api_version, request_id, next_cursor?}}`.
### Example
```bash
curl "https://data.tryopengrid.com/v1/exports" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```
# Download a day's export (/api-reference/bulk-exports/download-a-day-s-export)
## Download a day's export
`GET https://data.tryopengrid.com/v1/exports/{dataset}`
One completed UTC day of a dataset (gzipped JSON lines).
### Parameters
- `dataset` (path, required, string): `listings`, `listing_changes`, `index_levels` or `fixings`.
- `date` (query, required, string): a completed UTC day, YYYY-MM-DD
- `OpenGrid-Version` (header, string): The API version to shape the response for. Default: the version pinned to your key.
### Response
application/gzip
### Example
```bash
curl "https://data.tryopengrid.com/v1/exports/listings" \
-H "Authorization: Bearer $OPENGRID_API_KEY"
```