RWA Data API Guide: How to Find, Compare & Analyze Real-World Assets

1
2

requests==2.32.3
python-dotenv==1.0.1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import os
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("COINGECKO_API_KEY")

# Use the Demo base URL if you have a free Demo key.
# Switch to the Pro base URL once you upgrade to a paid plan.
BASE_URL = "https://api.coingecko.com/api/v3"
# BASE_URL = "https://pro-api.coingecko.com/api/v3"

HEADERS = {
    "accept": "application/json",
    "x-cg-demo-api-key": API_KEY,
    # Swap the header above for "x-cg-pro-api-key" if you switch to the Pro base URL.
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import requests
from config import BASE_URL, HEADERS

def get_rwa_list(asset_type=None):
    url = f"{BASE_URL}/rwas/list"
    params = {}
    if asset_type:
        # asset_type accepts "stock", "commodity", or "etf"
        params["asset_type"] = asset_type
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

def get_rwa_markets(ids=None, asset_type=None, price_change_percentage="24h,7d"):
    url = f"{BASE_URL}/rwas/markets"
    params = {"price_change_percentage": price_change_percentage}
    if ids:
        params["ids"] = ",".join(ids) if isinstance(ids, list) else ids
    if asset_type:
        params["asset_type"] = asset_type
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    rwas = get_rwa_list()
    print(f"Total RWAs tracked: {len(rwas)}")

    # Screen a mix of tokenized stocks, a leveraged ETF, and a tokenized commodity
    sample = get_rwa_markets(ids=["amazon", "adobe", "2x-bitcoin-strategy-etf", "gold"])
    for m in sample:
        data = m["tokenized_market_data"]
        print(m["id"], m["asset_type"], data["current_price"], data["market_cap"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import requests
from config import BASE_URL, HEADERS

def get_pre_ipo_stocks():
    url = f"{BASE_URL}/coins/markets"
    params = {
        "vs_currency": "usd",
        "category": "tokenized-pre-ipo-stocks",
        "order": "market_cap_desc",
        "per_page": 20,
        "page": 1,
    }
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

def get_rwa_by_id(rwa_id):
    url = f"{BASE_URL}/rwas/{rwa_id}"
    params = {"tokens": "true", "tokenized_market_data": "true"}
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    coins = get_pre_ipo_stocks()
    print(f"Tokenized pre-IPO stocks live: {len(coins)}")
    for c in coins:
        print(c["id"], c["symbol"], c["name"], c["market_cap"])

    openai = get_rwa_by_id("openai-pre-ipo")
    print(f"\n{openai['name']} aggregate price: {openai['tokenized_market_data']['current_price']}")
    for t in openai["tokens"]:
        print(" -", t["name"], "issued by", t["issuer_details"]["name"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import requests
from config import BASE_URL, HEADERS

def get_rwa_by_id(rwa_id):
    url = f"{BASE_URL}/rwas/{rwa_id}"
    # tokens and tokenized_market_data default to false.
    # Leave either one out and you will only get bare metadata back.
    params = {"tokens": "true", "tokenized_market_data": "true"}
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

def get_issuer(issuer_id):
    url = f"{BASE_URL}/rwas/issuers/{issuer_id}"
    response = requests.get(url, headers=HEADERS)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    rwa = get_rwa_by_id("openai-pre-ipo")
    print(f"{rwa['name']} is tracked as {len(rwa['tokens'])} separate tokens:")
    for token in rwa["tokens"]:
        # Not every token lists a platform yet, so only add the clause when one exists
        platform = next(iter(token["platforms"]), None)
        platform_note = f" on {platform}" if platform else ""
        print(f" - {token['name']} ({token['symbol'].upper()}){platform_note}, issued by {token['issuer_details']['name']}")

    issuer = get_issuer("republic-tokenized-pre-ipo-assets")
    print(f"\n{issuer['name']} has tokenized {len(issuer['tokens'])} assets worth ${issuer['market_cap']:,.0f} total")
    for t in issuer["tokens"]:
        print(" -", t["name"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import requests
from config import BASE_URL, HEADERS

def get_rwa_tickers(rwa_id, order="volume_desc", depth=False):
    url = f"{BASE_URL}/rwas/{rwa_id}/tickers"
    params = {"order": order, "depth": str(depth).lower()}
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    tickers = get_rwa_tickers("openai-pre-ipo", depth=True)
    for t in tickers["tickers"][:5]:
        spread = t["bid_ask_spread_percentage"]
        print(f"{t['market']['name']}: {t['converted_last']['usd']} USD, spread {spread}%, volume {t['converted_volume']['usd']}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import requests
from config import BASE_URL, HEADERS

def get_implied_spot_price(commodity_code):
    # commodity_code is "xau" for gold or "xag" for silver
    url = f"{BASE_URL}/exchange_rates"
    response = requests.get(url, headers=HEADERS)
    response.raise_for_status()
    rates = response.json()["rates"]
    # Both rates are quoted against BTC, so dividing USD by the commodity
    # rate gives you the implied USD spot price for one troy ounce
    return rates["usd"]["value"] / rates[commodity_code]["value"]

def get_tokenized_price(rwa_id):
    url = f"{BASE_URL}/rwas/{rwa_id}"
    params = {"tokenized_market_data": "true"}
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()["tokenized_market_data"]["current_price"]

if __name__ == "__main__":
    for rwa_id, code in [("gold", "xau"), ("silver", "xag")]:
        tokenized = get_tokenized_price(rwa_id)
        spot = get_implied_spot_price(code)
        premium = (tokenized - spot) / spot * 100
        label = "premium" if premium >= 0 else "discount"
        print(f"{rwa_id}: tokenized ${tokenized:,.2f} vs implied spot ${spot:,.2f}, a {abs(premium):.2f}% {label}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import requests
from config import BASE_URL, HEADERS

def get_market_chart(rwa_id, days=30):
    url = f"{BASE_URL}/rwas/{rwa_id}/market_chart"
    params = {"days": days}
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    chart = get_market_chart("openai-pre-ipo", days=30)
    print(f"\n{len(chart['tokenized_prices'])} price points over the last 30 days")
    print("First point:", chart["tokenized_prices"][0])
    print("Last point:", chart["tokenized_prices"][-1])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import requests
from config import BASE_URL, HEADERS

WATCHLIST = ["openai-pre-ipo", "spacex-pre-ipo", "gold", "silver"]

def get_watchlist_snapshot(ids):
    url = f"{BASE_URL}/rwas/markets"
    params = {
        "ids": ",".join(ids),
        "price_change_percentage": "24h",
    }
    response = requests.get(url, headers=HEADERS, params=params)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    snapshot = get_watchlist_snapshot(WATCHLIST)
    # The markets endpoint can only sort by market cap, volume, or id,
    # so sorting by biggest mover has to happen client-side after the fetch
    snapshot.sort(key=lambda x: x["tokenized_market_data"]["price_change_percentage_24h_in_currency"] or 0, reverse=True)
    print(f"{'Asset':<20}{'Price':>12}{'24h %':>10}{'Market Cap':>18}")
    for rwa in snapshot:
        data = rwa["tokenized_market_data"]
        change = data["price_change_percentage_24h_in_currency"] or 0
        print(f"{rwa['id']:<20}{data['current_price']:>12,.2f}{change:>+9.2f}%{data['market_cap']:>18,.0f}")