URD ATLAS
StatusTrack RecordThresholdsGlossaryFAQAPI DocsMethodology
Account
ChainsStatusTrack RecordThresholdsGlossaryFAQAPI DocsMethodology
Account
© 2026 Urd Atlas.
AboutTermsPrivacy
No price data · No forecasts · No recommendations
API Docs

Getting started with the
Urd Atlas JSON API

A complete beginner guide. No prior experience with APIs or JSON required. Read this from top to bottom before opening the technical reference.
← Back to API Docs
Contents
1. What JSON is2. What an API is3. What you actually receive4. The files — explained in full5. Automatic vs manual delivery6. What happens after you subscribe7. Your first API request8. What software you need locally9. How to analyse the data10. How to automate daily fetching11. Common questions answered12. What to do next
Chapter 1

What JSON is

JSON stands for JavaScript Object Notation. Despite the name, it has nothing to do with JavaScript in practice — it is simply a text format for storing and transmitting structured data. Any programming language can read it. You can also open it in a plain text editor.

A JSON file looks like this:

Example: a simple JSON file
{
  "chain": "bitcoin",
  "date": "2026-04-13",
  "status_label": "HEATING",
  "confidence_score": 0.82,
  "drivers": [
    { "metric": "tx_count_daily", "z_robust": 1.74 },
    { "metric": "median_tx_fee_native", "z_robust": -2.02 }
  ]
}
Curly braces { }

Wrap a group of named fields. Each field has a name (in quotes) and a value.

Square brackets [ ]

Wrap a list of items. Items can be numbers, text, or other objects.

Colon :

Separates a field name from its value. Comma separates multiple fields.

Key point: JSON is just text. It is not a program, not a database, and not a spreadsheet. It is a file — like a .txt file — that happens to be structured in a way that software can read easily.
Chapter 2

What an API is

API stands for Application Programming Interface. In plain language: it is a way for your computer to ask a server for data and get a structured response back. Instead of opening a webpage and reading it with your eyes, your script sends a request and receives machine-readable data directly.

The difference — with and without an API

Without API
Open browser → navigate to page → read regime label → write it down → repeat tomorrow → repeat for each chain → build your own table manually
Time per day: 10–30 minutes. Error-prone. Cannot be automated.
With API
Script runs → sends one request per chain → receives full JSON with all fields → saves files locally → done
Time per day: seconds. Fully automated. No manual steps.

What an API key is

An API key is a long string of characters that identifies you as a subscriber. You include it in every request so the server knows who you are and what you are entitled to access. Think of it like a key card — you swipe it every time you enter, and the system knows which rooms you are allowed into.

Example: what an API key looks like
ta_live_2c627b2852556cf57de58ae97d6476e27660cf1ebe9348a2
Important: Treat your API key like a password. Do not paste it into public files, share it in screenshots, or commit it to a public code repository. If compromised, revoke it from Dashboard and create a new one.
Fair-use limits: Authenticated API access is subject to technical rate limits and daily request quotas. By default, Single Chain access allows 500 authenticated file-delivery requests per UTC day, and Research access allows 5,000 authenticated file-delivery requests per UTC day. These limits protect service availability and help prevent accidental or abusive overuse.

API responses may include X-RateLimit-Limit, X-RateLimit-Remaining, X-DailyQuota-Limit, X-DailyQuota-Remaining, and Retry-After headers. If you receive a 429 response, slow down or wait until the relevant reset time before retrying.

Chapter 3

What you actually receive as a subscriber

When you subscribe to Urd Atlas, you get API access to structured JSON files. There are four published JSON genres. Gold, Derived, and Meta are the technical data layers; Briefs are the readable, direct-use JSON layer built from the latest Meta context. Here is the complete picture:

GenreWhat it containsBest for
GoldRaw daily chain metrics in native units. Transaction counts, fees, block times, active addresses.Your own calculations, raw data analysis
MetaThe regime label (STABLE/HEATING/CONGESTED/CHEAP), confidence score, scorecard, and ranked driver signals.Dashboards, alerts, research conditioning
Derived7-day and 30-day rolling averages for every Gold metric.Trend charts, smoothed analysis
BriefsShort descriptive JSON summaries of the latest regime context, including what changed, what drove it, and the non-advisory guardrails.Fast reading, reporting, onboarding, and non-pipeline workflows

Files available per plan

Single Chain — $49/mo — 1 chain

If your entitled chain is bitcoin, you can fetch:

/api/v1/files/gold/bitcoin/latest.json
/api/v1/files/meta/bitcoin/latest.json
/api/v1/files/derived/bitcoin/latest.json
/api/v1/files/briefs/chains/bitcoin/latest.json

/api/v1/files/gold/bitcoin/7d/latest.json
/api/v1/files/meta/bitcoin/7d/latest.json
/api/v1/files/derived/bitcoin/7d/latest.json

/api/v1/files/gold/bitcoin/30d/latest.json
/api/v1/files/meta/bitcoin/30d/latest.json
/api/v1/files/derived/bitcoin/30d/latest.json

/api/v1/files/gold/bitcoin/90d/latest.json
/api/v1/files/meta/bitcoin/90d/latest.json
/api/v1/files/derived/bitcoin/90d/latest.json

That is 13 current files in this example: Gold, Meta, and Derived across 4 windows, plus the latest per-chain Briefs JSON.

Research — $149/mo — all 4 chains

Same structure, but for all four chains and 6 windows (adds 180d and 365d):

/api/v1/files/meta/bitcoin/latest.json
/api/v1/files/meta/ethereum/latest.json
/api/v1/files/meta/arbitrum/latest.json
/api/v1/files/meta/base/latest.json
/api/v1/files/briefs/chains/bitcoin/latest.json
/api/v1/files/briefs/chains/ethereum/latest.json
/api/v1/files/briefs/chains/arbitrum/latest.json
/api/v1/files/briefs/chains/base/latest.json

/api/v1/files/meta/bitcoin/365d/latest.json
/api/v1/files/meta/ethereum/365d/latest.json
...and so on for gold and derived. Briefs are published as latest per-chain files.

That is 72 technical window files — 3 technical genres × 4 chains × 6 windows — plus 4 latest per-chain Briefs JSON files.

Chapter 4

The window files — explained in full

This is where most new subscribers get confused. The URL structure looks like this:

URL structure
/api/v1/files/{genre}/{chain}/{window}/latest.json
/api/v1/files/{genre}/{chain}/latest.json
/api/v1/files/briefs/chains/{chain}/latest.json
Q

What does 'latest.json' (without a window) mean?

This is always the most recently published file for today. It contains data for the most recent date the pipeline has published. This file is updated every day when the pipeline runs.Fetch this every day to always have the newest data.
Q

What does '90d/latest.json' mean?

This is a bundle file containing the last 90 days of data in a single JSON file. It is not 90 separate files — it is one file with an array of 90 daily records.
What the 90d file looks like inside
{
  "chain": "bitcoin",
  "window": "90d",
  "days": [
    { "date": "2026-01-14", "status_label": "STABLE", "confidence_score": 0.79, ... },
    { "date": "2026-01-15", "status_label": "STABLE", "confidence_score": 0.81, ... },
    { "date": "2026-01-16", "status_label": "HEATING", "confidence_score": 0.76, ... },
    ...90 records total
  ]
}
This file is also updated every day — it always contains the most recent 90 days, rolling forward one day at a time.
Q

Is the 90d file the same every day, or does it change?

It changes every day. Every morning after the pipeline runs, the 90d file is updated to include the newest day and drop the oldest day. It is always a rolling 90-day window ending on the most recent published date. Think of it like a conveyor belt — one new day gets added at the front, one old day falls off the back.
Q

Which file should I fetch every day?

For daily monitoring: fetch latest.json (without a window). One request per chain, one file, always fresh.

For building a historical dataset: fetch 90d/latest.jsononce when you sign up to get your history, then fetch latest.jsondaily to add one new day at a time.

For backtesting or analysis over a long period: fetch the largest window your plan allows (90d for Single Chain,365d for Research) to get everything in one request.
Q

What are the available windows?

Window tokenWhat it containsAvailable on
latestMost recent single day onlySingle Chain + Research
7dLast 7 days as an arraySingle Chain + Research
30dLast 30 days as an arraySingle Chain + Research
90dLast 90 days as an arraySingle Chain + Research
180dLast 180 days as an arrayResearch only
365dLast 365 days as an arrayResearch only
Chapter 5

Do I get the data automatically, or do I have to fetch it manually?

Short answer: Urd Atlas publishes new files every day automatically. But they are not pushed to you — you must fetch them. Think of it like a library that gets new books every morning: the books arrive automatically, but you still have to go pick them up.

What Urd Atlas does automatically

  • Runs the classification pipeline every day
  • Publishes new Gold, Derived, Meta, and Briefs files for each chain
  • Updates the window bundle files (7d, 30d, 90d, etc.) to include the new day
  • Makes all files available on the API immediately after publication
  • Updates the public /status endpoint so you can check freshness

What you do

  • Send a GET request to the API with your API key
  • Receive the JSON file as the response body
  • Save it locally or pass it directly to your script
  • Optionally: automate this with a scheduled script

Two ways subscribers work

Manual (start here)

You open a terminal and run one command. You get the file. You repeat when you want new data. No setup, no scheduler, no code. Good for: occasional checks, one-off analysis, getting started.

Automated (next step)

You write a small script that checks for new data and downloads it if found. You schedule it to run every day. Good for: daily archives, feeding a dashboard, keeping data fresh without thinking about it.

Chapter 6

What happens step by step after you subscribe

1

Complete payment on Stripe

Click "Start Single Chain" or "Start Research" on the plans page. For Single Chain, choose your chain first. You are redirected to Stripe's checkout page. Enter your card details. Your subscription is active immediately after payment.
2

Arrive at your Dashboard

After payment, you land on the Dashboard. It shows your plan, entitled chain (Single Chain) or all chains (Research), allowed windows, and history depth. This is your subscriber control panel.
3

Create an API key

In Dashboard, give your key a label (e.g. "my laptop") and click Create. The full key appears once — copy it immediately and store it safely. A password manager or a local .env file works well.
4

Make your first request

Open a terminal. Run:
curl -H "X-API-Key: YOUR_KEY" \
  https://urdatlas.com/api/v1/files/meta/bitcoin/latest.json
You will see a full JSON response printed.
5

Save the file

Add -o filename.json to save to disk:
curl -H "X-API-Key: YOUR_KEY" \
  https://urdatlas.com/api/v1/files/meta/bitcoin/latest.json \
  -o bitcoin_meta_latest.json
6

You are done — for now

You have a local JSON file. Open it in a text editor to see the data. Load it into Python, Excel, or whatever tool you use. Come back tomorrow and fetch again — or automate it (see Chapter 10).
Total time for steps 1–6: Under 10 minutes. Everything after this is optional enhancement.
API key rules

How API keys are checked

One key, current entitlement

The API key does not permanently store a separate plan. Each request is checked against the account's current subscription status, entitled chain, allowed file genres, and allowed history window. If the subscription is inactive, subscriber file delivery is blocked even if the key string itself still exists.

Maximum two non-revoked keys

Each account can have up to two non-revoked API keys. Active and suspended keys count toward this limit. Revoked keys do not count. To create a third key, revoke an existing key first from Dashboard.

Single Chain scope

Single Chain keys can fetch Gold, Meta, Derived, and Briefs for the selected chain only. Available windows are latest, 7d, 30d, and 90d. Requests for another chain or for 180d/365d return a forbidden response.

Research scope

Research keys can fetch Gold, Meta, Derived, and Briefs for Bitcoin, Ethereum, Arbitrum, and Base. Available windows are latest, 7d, 30d, 90d, 180d, and 365d.

Cancellation behavior: API keys work only while the subscription is active. If cancellation is scheduled for the end of the billing period, access remains active until then. If the subscription is cancelled immediately, subscriber API access stops when the subscription status becomes inactive.
Chapter 7

How to make your first API request

There are several ways to make an HTTP request. Pick the one that matches what you already have installed.

Option A: curl (simplest — works on Windows, Mac, Linux)

curl is usually pre-installed. Open any terminal and run:

curl -H "X-API-Key: YOUR_KEY_HERE" https://urdatlas.com/api/v1/files/meta/bitcoin/latest.json

To save to a file instead of printing:

curl -H "X-API-Key: YOUR_KEY_HERE" https://urdatlas.com/api/v1/files/meta/bitcoin/latest.json -o meta_bitcoin_latest.json

Option B: Python (recommended for analysis)

Install requests once: pip install requests

import requests, json

API_KEY = "YOUR_KEY_HERE"
url = "https://urdatlas.com/api/v1/files/meta/bitcoin/latest.json"

response = requests.get(url, headers={"X-API-Key": API_KEY}, timeout=30)
response.raise_for_status()  # raises an error if request failed

data = response.json()
print(data["status"]["label"])         # prints e.g. HEATING
print(data["confidence"]["confidence_score"])  # prints e.g. 0.82

# Save to file
with open("meta_bitcoin_latest.json", "w") as f:
    json.dump(data, f, indent=2)

Option C: PowerShell (Windows)

$key = "YOUR_KEY_HERE"
$url = "https://urdatlas.com/api/v1/files/meta/bitcoin/latest.json"
$headers = @{ "X-API-Key" = $key }

$response = Invoke-RestMethod -Uri $url -Headers $headers
$response | ConvertTo-Json -Depth 10 | Out-File -FilePath "meta_bitcoin_latest.json"
Chapter 8

What software you need on your computer

You do not need much. Here is the minimum and the recommended setup.

Minimum (already have)

  • A terminal (Command Prompt, PowerShell, or Terminal on Mac/Linux)
  • curl — usually pre-installed
  • A text editor to open JSON files (Notepad works, VS Code is better)

Good enough for: manual daily fetching and reading the output.

Recommended for analysis

  • Python 3.x — free at python.org
  • pip install requests (one command)
  • pip install pandas (for data manipulation)
  • VS Code — free code editor at code.visualstudio.com
  • Jupyter Notebook — for interactive analysis (pip install jupyter)

Good for: building your own analysis, charts, and automation.

For non-coders

  • Excel or Google Sheets — can load JSON with a bit of setup
  • Power Query in Excel — imports JSON natively
  • Postman — visual tool for testing API requests (free)
  • Zapier or Make — no-code automation platforms

Good for: spreadsheet users who want structured data without writing code.

Chapter 9

How to analyse the data — practical examples

Once you have JSON files on your computer, here are the most common things new subscribers want to do with them.

Read the regime label and confidence from a file

import json

with open("meta_bitcoin_latest.json") as f:
    data = json.load(f)

label = data["status"]["label"]           # e.g. "HEATING"
confidence = data["confidence"]["confidence_score"]  # e.g. 0.82
date = data["date"]                       # e.g. "2026-04-13"

print(f"{date}: {label} (confidence: {confidence:.2f})")

Load a 90-day history file into a table (pandas)

import json
import pandas as pd

with open("meta_bitcoin_90d.json") as f:
    data = json.load(f)

# The days array contains one record per day
rows = []
for day in data["days"]:
    rows.append({
        "date": day["date"],
        "label": day["status"]["label"],
        "confidence": day["confidence"]["confidence_score"],
    })

df = pd.DataFrame(rows)
df["date"] = pd.to_datetime(df["date"])
df = df.sort_values("date")

print(df.tail(10))  # show last 10 rows
print(df["label"].value_counts())  # how many days each label appeared

Compare all four chains (Research) — build a daily summary table

import requests, pandas as pd

API_KEY = "YOUR_KEY_HERE"
CHAINS = ["bitcoin", "ethereum", "arbitrum", "base"]

rows = []
for chain in CHAINS:
    url = f"https://urdatlas.com/api/v1/files/meta/{chain}/latest.json"
    data = requests.get(url, headers={"X-API-Key": API_KEY}).json()
    rows.append({
        "chain": chain,
        "label": data["status"]["label"],
        "confidence": data["confidence"]["confidence_score"],
        "date": data["date"],
    })

df = pd.DataFrame(rows)
print(df.to_string(index=False))

Load into Excel — no code required

  • Open Excel → Data tab → Get Data → From File → From JSON
  • Select your .json file
  • Excel opens Power Query Editor — click the fields you want to expand
  • Click Load — you get a table with one row per day
  • Refresh tomorrow: Data → Refresh All

This works best with the window files (90d, 365d) because they contain an array of daily records. The latest.json file contains only one day.

Chapter 10

How to automate daily fetching

Do not automate until the manual version works. First: fetch one file manually. Then: fetch it in a script. Then: schedule that script.

The recommended beginner automation pattern

Instead of fetching blindly every day, the script checks the public status endpoint first. If the published date has changed since the last fetch, it downloads the new file. This avoids unnecessary requests and makes logs easy to read.

Save this as fetch_urdatlas.py
import json, os
from pathlib import Path
import requests

BASE_URL = "https://urdatlas.com"
API_KEY = os.environ["URD_ATLAS_API_KEY"]  # set this as environment variable — never hardcode

CHAIN = "bitcoin"   # change to your entitled chain
GENRE = "meta"      # gold, meta, derived, or briefs

DATA_DIR = Path("urdatlas_data") / GENRE / CHAIN
STATE_FILE = Path("urdatlas_state") / f"{CHAIN}_{GENRE}.json"
DATA_DIR.mkdir(parents=True, exist_ok=True)
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)

def get_last_seen():
    if not STATE_FILE.exists():
        return None
    return json.loads(STATE_FILE.read_text())

def save_last_seen(as_of):
    STATE_FILE.write_text(json.dumps({"as_of": as_of}))

def check_status():
    r = requests.get(f"{BASE_URL}/api/v1/status", timeout=30)
    r.raise_for_status()
    chains = r.json().get("chains", [])
    for row in chains:
        if row.get("chain") == CHAIN:
            return row.get("as_of")
    raise RuntimeError(f"Chain {CHAIN} not found in status")

def fetch_file():
    path = f"briefs/chains/{CHAIN}/latest.json" if GENRE == "briefs" else f"{GENRE}/{CHAIN}/latest.json"
    url = f"{BASE_URL}/api/v1/files/{path}"
    r = requests.get(url, headers={"X-API-Key": API_KEY}, timeout=30)
    r.raise_for_status()
    return r.json()

def main():
    current_as_of = check_status()
    last_seen = get_last_seen()

    if last_seen and last_seen.get("as_of") == current_as_of:
        print(f"No new data. Still at {current_as_of}.")
        return

    data = fetch_file()
    out = DATA_DIR / f"{current_as_of}_latest.json"
    out.write_text(json.dumps(data, indent=2))
    save_last_seen(current_as_of)
    print(f"Saved: {out}")

if __name__ == "__main__":
    main()

Set your API key as an environment variable

Windows (Command Prompt)
set URD_ATLAS_API_KEY=your_key_here
python fetch_urdatlas.py
Mac / Linux
export URD_ATLAS_API_KEY=your_key_here
python3 fetch_urdatlas.py

Schedule on Windows — Task Scheduler

  • Press Windows key → search Task Scheduler → Open it
  • Click Create Basic Task in the right panel
  • Name: Urd Atlas Daily Fetch
  • Trigger: Daily — set a time in the afternoon (data publishes during the day)
  • Action: Start a program
  • Program: path to your Python, e.g. C:\Python311\python.exe
  • Arguments: path to your script, e.g. C:\scripts\fetch_urdatlas.py
  • Finish — the task runs automatically every day

Schedule on Mac / Linux — cron

Open Terminal and type crontab -e, then add:

# Run every day at 14:00 and 18:00 (catches most publication windows)
0 14,18 * * * URD_ATLAS_API_KEY=your_key /usr/bin/python3 /home/you/fetch_urdatlas.py >> /home/you/urdatlas.log 2>&1

Save and exit. Cron runs the script automatically. Check the log file to see what happened.

Chapter 11

Common questions — answered directly

Q

Do I need to be a developer?

No. The simplest workflow is: create account → subscribe → create API key → run one curl command → save the file. You can do this without writing any code.
Q

What time does the new data arrive?

The pipeline runs twice daily at approximately 09:00 and 21:00 Europe/Oslo. Check /status to see the latest published date. When the date changes, new files are available.
Q

Do I get notified when new data is available?

No push notification or email. The recommended approach: poll the status endpoint every few hours and check if the as_of date has changed.
Q

What happens if I miss a day?

Nothing is lost. You can fetch the window files (7d, 30d, 90d) to get any days you missed, within your plan history depth.
Q

Can I use the same API key on multiple machines?

Q

How many API keys can I create?

Each account can have up to two non-revoked API keys. Active and suspended keys count toward this limit. Revoked keys do not count. If you need to create a third key, revoke an existing key first from Dashboard.
Yes. Copy the key string and use it wherever you want. You can also create a second key in Dashboard for a different machine.
Q

Is the JSON format the same for Single Chain and Research?

Yes — identical format. The difference is scope: which chains and how many days of history you can access, not the structure of the files.
Q

What does the confidence score mean exactly?

It is a number from 0 to 1. Above 0.40, the model publishes a named label. Below 0.40, it publishes UNKNOWN/DEGRADED to avoid overclaiming on weak evidence. A score of 0.80+ means strong, consistent evidence across all metrics.
Q

What happens to my data if I cancel my subscription?

Your API key stops working at the end of your billing period. Files you have already downloaded and saved locally are yours to keep — we do not delete them.
Q

I get a 403 error — what does that mean?

A 403 means your request is outside your entitlement. Common causes: requesting a chain you are not entitled to (Single Chain only gets one chain), requesting a window larger than your plan allows (e.g. 365d on Single Chain), or your subscription is not active. Check Dashboard to confirm your plan status.
Q

I get a 401 error — what does that mean?

A 401 means authentication failed. Check that you are sending the API key in the header named exactly X-API-Key and that the key value is correct. API keys are case-sensitive.
Chapter 12

What to do after reading this guide

1. Dashboard
Create your API key. Start here — everything depends on having a key.
2. API Docs
Technical route reference with all endpoints, parameters, and error codes.
3. JSON Schema
Every field in every file explained in full. Use this when you encounter an unfamiliar field.
4. Methodology
How the regime classification works — baselines, persistence filter, confidence gate.