How to Get Anthropic Pre-IPO Data With the CoinGecko API

Anthropic remains a private company, so there is no publicly traded Anthropic stock. However, tokenized Anthropic pre-IPO assets provide a source of live market data that can be tracked through CoinGecko.

This guide explains what Anthropic’s pre-IPO data represents, why different price numbers appear online, and how to pull Anthropic’s tokenized market data with the CoinGecko API. It also shows how to verify the data directly from the source rather than relying on third-party broker pages.

Disclaimer: This guide covers data access only and is not investment advice. CoinGecko API provides market data for tokenized real-world assets. It does not facilitate trading or acquisition of these assets.

Is Anthropic Stock Publicly Traded?

Anthropic is not publicly traded. It is privately held and has no ticker on a public exchange. The company confidentially filed for an IPO with the SEC in June 2026 and selected Nasdaq for its potential IPO.

A confidential IPO filing is part of the process of going public, but Anthropic remains privately held until its shares are publicly listed.

When Is Anthropic’s IPO?

Anthropic’s IPO timeline has moved more than once. It was previously expected in late September or mid-October 2026, but the latest reporting suggests the listing could be delayed until after the November 2026 U.S. elections. Anthropic has not set a public listing date, so treat any reported timeline as provisional and check current reporting for updates.

Can You Buy Anthropic Pre-IPO Shares?

CoinGecko provides market data for Anthropic’s tokenized pre-IPO asset, rather than access to the company’s private shares. Accredited investors can access private-company shares through secondary-market platforms such as Forge Global, Hiive, and EquityZen, while tokenized pre-IPO exposure is available through PreStocks.

This article covers the tokenized option through PreStocks’ Solana token, which trades on the DEXs listed in the RWA Tickers endpoint. Each ticker can include a trade_url that points directly to the trading venue:

{
  "market": {
    "name": "Manifest"
  },
  "trade_url": "https://app.manifest.trade/market/61mmsZUgoFNuqzXDsRH9TV2U9zc5aL1H5pKKA2pogsCC"
}

You can also view the same market data without writing code on the Anthropic (Pre-IPO) RWA page and Anthropic PreStocks token page. Both show the tokenized market price, while the underlying Anthropic shares remain private until they are publicly listed.

How to Pull Anthropic’s Pre-IPO Data With the CoinGecko API

Prerequisites

You’ll need a CoinGecko API key. If you don’t have one, follow the guide to get a free Demo API key. The Demo plan covers resolving the asset and reading its snapshot and issuer details below. Pulling live tickers, price history, and holder and trader data requires a paid plan from $29/month only.

Your API key type must match the base URL and authentication header used in your requests:

To run the full script included at the end of this guide, you’ll need Python 3.8+. Install the official SDK and requests:

Step 1: Resolve the RWA ID

CoinGecko’s RWA List endpoint returns every tokenized real-world asset it tracks in one unpaginated call, including Anthropic’s pre-IPO listing. Pre-IPO companies use asset_type: "stock", the same value used for publicly listed tokenized equities, so there is no separate pre-ipo value to filter on. Call it once to find the RWA ID you’ll use throughout this guide — anthropic-pre-ipo.

curl -s "https://api.coingecko.com/api/v3/rwas/list" \
-H "x-cg-demo-api-key: YOUR_API_KEY" \
| jq '.[] | select(.id == "anthropic-pre-ipo")'

# Python SDK equivalent:
# pip install coingecko-sdk
# from coingecko_sdk import Coingecko
# client = Coingecko(demo_api_key="YOUR_API_KEY", environment="demo")
# rwas = client.rwas.get_list()

Here’s what the response looks like:

{
  "id": "anthropic-pre-ipo",
  "symbol": "anthropic",
  "name": "Anthropic (Pre-IPO)",
  "asset_type": "stock"
}

Step 2: Pull the asset snapshot

The RWA Data by ID endpoint returns the asset’s current tokenized market data and the tokens[] array of issuer tokens behind it. For Anthropic, this market data belongs to the PreStocks token. Tokenized market data reflects activity for the tokenized asset and may differ from the underlying company’s broader valuation. For more context, refer to our RWA Data API Guide. The tokens[] array currently lists PreStocks as the only issuer.

curl -s "https://api.coingecko.com/api/v3/rwas/anthropic-pre-ipo?tokens=true&tokenized_market_data=true" \
-H "x-cg-demo-api-key: YOUR_API_KEY"

# client.rwas.get_id(id="anthropic-pre-ipo", tokens=True, tokenized_market_data=True)

Here’s what the response looks like:

{
  "id": "anthropic-pre-ipo",
  "tokenized_market_data": {
    "current_price": 1132.29,
    "market_cap": 8358100.63,
    "total_volume": 2519804.57
  },
  "tokens": [
    {
      "id": "anthropic-prestocks-2",
      "name": "Anthropic PreStocks",
      "issuer_details": {
        "id": "prestocks-ecosystem",
        "name": "PreStocks"
      },
      "platforms": {
        "solana": "Pren1FvFX6J3E4kXhJuCiAD5aDmGEb7qJRncwA8Lkhw"
      }
    }
  ]
}

Step 3: Get issuer-level context

The RWA Issuer Data by ID endpoint returns an issuer’s aggregate market cap, 24-hour volume, and every token it issues. PreStocks is currently the only issuer tokenizing Anthropic. PreStocks is currently the only issuer tokenizing Anthropic, giving you the issuer-level context, such as market cap, volume, and related tokens, to evaluate the issuer behind the tokenized asset.

curl -s "https://api.coingecko.com/api/v3/rwas/issuers/prestocks-ecosystem" \
-H "x-cg-demo-api-key: YOUR_API_KEY"

# client.rwas.issuers.get_id("prestocks-ecosystem")

Here’s what the response looks like:

{
  "name": "PreStocks",
  "market_cap": 20789844.84,
  "volume_24h": 4316649.02,
  "tokens": [
    {
      "name": "Anduril PreStocks"
    },
    {
      "name": "Anthropic PreStocks"
    },
    {
      "name": "Kalshi PreStocks"
    },
    {
      "name": "OpenAI PreStocks"
    },
    {
      "name": "Polymarket PreStocks"
    },
    {
      "name": "SpaceX PreStocks"
    },
    {
      "name": "xAI PreStocks"
    }
  ]
}

Step 4: Get Live Tickers and Validate Data

CoinGecko’s RWA Tickers by ID endpoint (Basic Plan and above) lists every CEX and DEX venue trading the token, with is_stale and is_anomaly flags to help you identify quotes that may need closer review. Results are paginated at 100 tickers per page, and you can narrow them with issuer_ids or exchange_ids as more venues or issuers list the token.

cost_to_move_up_usd and cost_to_move_down_usd, returned when you pass depth=true, show the dollar cost to move a venue’s price up or down by 2%. These values help indicate the available liquidity on each venue.

curl -s "https://pro-api.coingecko.com/api/v3/rwas/anthropic-pre-ipo/tickers?depth=true" \
-H "x-cg-pro-api-key: YOUR_API_KEY"

# client.rwas.tickers.get(id="anthropic-pre-ipo", depth=True)

The API returns the following:

{
  "tickers": [
    {
      "market": {
        "name": "Meteora"
      },
      "converted_last": {
        "usd": 1105.98
      },
      "is_stale": false,
      "is_anomaly": false,
      "cost_to_move_up_usd": 393.3,
      "cost_to_move_down_usd": 392.12
    }
  ]
}

Step 5: Pull price history

CoinGecko’s RWA Historical Chart Data by ID endpoint (Basic Plan and above) returns the token’s historical price, market cap, and volume as [timestamp, value] arrays. days=max returns the full history at daily granularity. Shorter ranges such as days=30 automatically use finer granularity, or you can set it explicitly with interval (5m, hourly, or daily).

curl -s "https://pro-api.coingecko.com/api/v3/rwas/anthropic-pre-ipo/market_chart?days=max" \
-H "x-cg-pro-api-key: YOUR_API_KEY"

# client.rwas.market_chart.get(id="anthropic-pre-ipo", days="max")

The API returns the following:

{
  "tokenized_prices": [
    [
      1758672000000,
      144.51
    ],
    "... 371 more daily points ...",
    [
      1790812800000,
      1121.4
    ]
  ]
}

Here’s the tokenized_prices series charted for the last 90 days:

Step 6: Track Who’s Holding and Trading It

The RWA suite above covers market data, while the onchain endpoints let you see who holds and trades the token. Top Token Holders by Token Address (top_holders) ranks wallets by balance, Top Token Traders by Token Address (top_traders) ranks them by realized and unrealized PnL, and Historical Token Holders Chart by Token Address (holders_chart) tracks holder count over time. All three require the CoinGecko API Analyst Plan or above and support Anthropic PreStocks as an SPL token.

The holders and traders count parameters accept max to return all available wallets, while include_pnl_details adds average buy price and realized and unrealized PnL to top_holders.

curl -s "https://pro-api.coingecko.com/api/v3/onchain/networks/solana/tokens/Pren1FvFX6J3E4kXhJuCiAD5aDmGEb7qJRncwA8Lkhw/top_holders?holders=5" \
-H "x-cg-pro-api-key: YOUR_API_KEY"

# client.onchain.networks.tokens.top_holders.get(address="Pren1FvFX6J3E4kXhJuCiAD5aDmGEb7qJRncwA8Lkhw", network="solana", holders="5")

The API returns the following:

{
  "data": {
    "attributes": {
      "holders": [
        {
          "rank": 1,
          "address": "HkvpFqa3WngHoQcfLttAX4am7Ng8vezF6EEGRSbMsRj9",
          "percentage": "19.9684",
          "value": "1616759.02"
        },
        {
          "rank": 2,
          "address": "2sujbbTjp2r5ugbjfHgUNDSwtdVfYpTiCSKPgT84CvD7",
          "percentage": "6.1054",
          "value": "494329.89"
        }
      ]
    }
  }
}

Run the Full Script

The full workflow is combined into one script, from resolving the Anthropic asset to pulling its market and wallet data.

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

import os
import requests

API_KEY = os.environ["COINGECKO_PRO_API_KEY"]
BASE_URL = "https://pro-api.coingecko.com/api/v3"
HEADERS = {"x-cg-pro-api-key": API_KEY}

RWA_ID = "anthropic-pre-ipo"
TOKEN_ADDRESS = "Pren1FvFX6J3E4kXhJuCiAD5aDmGEb7qJRncwA8Lkhw"
NETWORK = "solana"


def resolve_rwa_id():
    resp = requests.get(f"{BASE_URL}/rwas/list", headers=HEADERS)
    resp.raise_for_status()
    # client.rwas.get_list()
    match = next((r for r in resp.json() if r["id"] == RWA_ID), None)
    if not match:
        raise SystemExit(f"{RWA_ID} not found in /rwas/list")
    return match


def get_asset_snapshot():
    params = {"tokens": "true", "tokenized_market_data": "true"}
    resp = requests.get(f"{BASE_URL}/rwas/{RWA_ID}", headers=HEADERS, params=params)
    resp.raise_for_status()
    # client.rwas.get_id(id=RWA_ID, tokens=True, tokenized_market_data=True)
    return resp.json()


def get_issuer_snapshot(issuer_id):
    resp = requests.get(f"{BASE_URL}/rwas/issuers/{issuer_id}", headers=HEADERS)
    resp.raise_for_status()
    # client.rwas.issuers.get_id(issuer_id)
    return resp.json()


def get_live_tickers():
    resp = requests.get(f"{BASE_URL}/rwas/{RWA_ID}/tickers", headers=HEADERS)
    resp.raise_for_status()
    # client.rwas.tickers.get(id=RWA_ID)
    return resp.json()["tickers"]


def get_price_history(days="30"):
    resp = requests.get(
        f"{BASE_URL}/rwas/{RWA_ID}/market_chart", headers=HEADERS, params={"days": days}
    )
    resp.raise_for_status()
    # client.rwas.market_chart.get(id=RWA_ID, days=days)
    return resp.json()


def get_holder_and_trader_activity():
    onchain_base = f"{BASE_URL}/onchain/networks/{NETWORK}/tokens/{TOKEN_ADDRESS}"
    holders = requests.get(f"{onchain_base}/top_holders", headers=HEADERS, params={"holders": "5"})
    holders.raise_for_status()
    # client.onchain.networks.tokens.top_holders.get(address=TOKEN_ADDRESS, network=NETWORK, holders="5")
    traders = requests.get(f"{onchain_base}/top_traders", headers=HEADERS, params={"traders": "5"})
    traders.raise_for_status()
    # client.onchain.networks.tokens.top_traders.get(token_address=TOKEN_ADDRESS, network_id=NETWORK, traders="5")
    chart = requests.get(f"{onchain_base}/holders_chart", headers=HEADERS, params={"days": "30"})
    chart.raise_for_status()
    # client.onchain.networks.tokens.holders_chart.get(token_address=TOKEN_ADDRESS, network=NETWORK, days="30")
    return holders.json(), traders.json(), chart.json()


def main():
    listing = resolve_rwa_id()
    print(f"Resolved: {listing['name']} ({listing['id']}), asset_type={listing['asset_type']}")

    asset = get_asset_snapshot()
    market = asset["tokenized_market_data"]
    token = asset["tokens"][0]
    print(f"Tokenized price: ${market['current_price']:,.2f}")
    print(f"Tokenized market cap: ${market['market_cap']:,.2f}")
    print(f"24h volume: ${market['total_volume']:,.2f}")
    print(f"Issued by: {token['issuer_details']['name']} on {list(token['platforms'].keys())[0]}")

    issuer = get_issuer_snapshot(token["issuer_details"]["id"])
    print(f"\n{issuer['name']} issuer profile:")
    print(f"  Market cap: ${issuer['market_cap']:,.2f}")
    print(f"  24h volume: ${issuer['volume_24h']:,.2f}")
    print(f"  Tokenizes {len(issuer['tokens'])} assets total")

    tickers = get_live_tickers()
    print(f"\n{len(tickers)} live venue tickers:")
    for t in tickers[:5]:
        flags = []
        if t["is_stale"]:
            flags.append("STALE")
        if t["is_anomaly"]:
            flags.append("ANOMALY")
        flag_str = f" [{', '.join(flags)}]" if flags else ""
        usd_price = t["converted_last"].get("usd")  # not every venue quotes a USD pair
        price_str = f"${usd_price:,.2f}" if usd_price is not None else "n/a"
        print(f"  {t['market']['name']}: {price_str}{flag_str}")

    history = get_price_history(days="30")
    prices = history["tokenized_prices"]
    print(f"\n{len(prices)} price points over the last 30 days")
    print(f"  First: {prices[0]}")
    print(f"  Last:  {prices[-1]}")

    holders, traders, holders_chart = get_holder_and_trader_activity()
    holder_list = holders["data"]["attributes"]["holders"]
    trader_list = traders["data"]["attributes"]["traders"]
    holder_counts = holders_chart["data"]["attributes"]["token_holders_list"]
    print(f"\nTop holder controls {holder_list[0]['percentage']}% of supply")
    print(f"Top trader realized PnL: ${float(trader_list[0]['realized_pnl_usd']):,.2f}")
    print(f"Holder count: {holder_counts[0][1]} -> {holder_counts[-1][1]} over the window")


if __name__ == "__main__":
    main()

Output from an actual run:

Resolved: Anthropic (Pre-IPO) (anthropic-pre-ipo), asset_type=stock
Tokenized price: $1,020.85
Tokenized market cap: $7,841,526.32
24h volume: $266,963.52
Issued by: PreStocks on solana

PreStocks issuer profile:
Market cap: $20,968,013.06
24h volume: $395,704.51
Tokenizes 7 assets total

12 live venue tickers:
Meteora: $1,021.46
Meteora: $1,020.99
Manifest: $1,021.46
Manifest: $1,013.53
Raydium (CLMM): $1,021.46

721 price points over the last 30 days
First: [1788832800000, 945.8220743674624]
Last:  [1791424800000, 1023.3513998586911]

Top holder controls 19.1892% of supply
Top trader realized PnL: $976,164.24
Holder count: 29077 -> 58205 over the window

How to Monitor Anthropic’s Pre-IPO Data In Real-Time

Stream live price and trades via WebSocket

CoinGecko’s WebSocket (Basic Plan and above) streams price and trade updates continuously, so you can receive updates without polling.

Connect to wss://stream.coingecko.com/v1?x_cg_pro_api_key=YOUR_API_KEY, then subscribe to three channels:

• OnchainSimpleTokenPrice for live price updates. It uses a network_id:token_address pair.
• OnchainTrade for live DEX trade updates. It uses a network_id:pool_addresses field.
• OnchainOHLCV for live candlestick data, letting you stream candles directly into a chart instead of building them yourself from ticks. It uses a network_id:pool_addresses field, an interval, and a token side.

After connecting, send these two messages in order. The first subscribes to the channel, and the second specifies which token to watch.

{"command":"subscribe","identifier":"{\"channel\":\"OnchainSimpleTokenPrice\"}"}
{"command":"message","identifier":"{\"channel\":\"OnchainSimpleTokenPrice\"}","data":"
{\"network_id:token_addresses\":
[\"solana:Pren1FvFX6J3E4kXhJuCiAD5aDmGEb7qJRncwA8Lkhw\"],\"action\":\"set_tokens\"}"}

The same pattern applies to OnchainOHLCV, with a different channel name and response fields.

{"command":"subscribe","identifier":"{\"channel\":\"OnchainOHLCV\"}"}
{"command":"message","identifier":"{\"channel\":\"OnchainOHLCV\"}","data":"
{\"network_id:pool_addresses\":
[\"solana:EZyszDEx1LZDt7TsSFV8xdPi49sDKC3mdfv2MVMEQLtU\"],\"interval\":\"1h\",\"token\":\"base\",\"action\":\"set_pools\"}"}

Once subscribed, an example live feed looks like this:

Get notified about asset changes via Webhook

CoinGecko’s webhooks (Basic Plan and above) push updates directly to your endpoint, so you receive them automatically.

The webhook cg.coin.info.updated event triggers when indexed coin metadata changes, including ticker, name, categorization, security notices, or contract addresses. For tokens that can migrate contracts, this provides a way to detect contract-address changes without polling.

Here’s what the notification can look like:

For a step-by-step guide to setting up CoinGecko webhooks, see How to Get Real-Time Crypto Updates via Webhook.

How to Read Anthropic’s Tokenized Data

The numbers above are real market data, but they represent different things. The asset snapshot in Step 2 showed that the tokenized market cap and Anthropic’s company valuation are different numbers. The tokenized market cap reflects the token’s market price and circulating supply, while Anthropic’s valuation comes from its funding rounds. Neither figure represents the other, so changes in the tokenized market cap do not directly indicate changes in Anthropic’s company valuation. For more context on how tokenized prices compare with company valuations and perpetual futures, read our analysis of Anthropic and OpenAI’s crypto-enabled pre-IPO markets.

CoinGecko’s RWA data gives you the tokenized market price directly, so you can use the data to make your own comparisons with an external benchmark. This applies across the RWA product, including tokenized versions of publicly listed companies such as NVIDIA.

Conclusion

With CoinGecko’s API, you can build a data pipeline for Anthropic’s tokenized pre-IPO asset, from discovering the asset and issuer to pulling live market data, historical prices, and wallet-level holder and trader activity. The same API endpoints extend to other PreStocks tokenized pre-IPO assets, as well as tokenized stocks and ETFs more broadly.

You can also pull the same data for OpenAI, SpaceX, and the rest of PreStocks’ pre-IPO lineup using the RWA Data API Guide. For a different use case, see this worked example of tracking who holds and trades a token

Ready to start building? Sign up for a free Demo API plan today to start tracking tokenized RWA assets and issuers, including live tokenized price and market cap. As your application scales, upgrade to a CoinGecko API paid plan for the higher limits and access needed to run production workloads, including live market updates, historical data, WebSocket and webhook delivery, and wallet-level holder and trader tracking.