Discover/Centrifuge API
live

Centrifuge APIdocs.centrifuge.io

Query Centrifuge protocol pools, tokens, vaults, investor transactions, and positions. Plus full documentation search and page content extraction via 9 endpoints.

Endpoint health
verified 3d ago
get_site_navigation
get_page_content
graphql_query
graphql_query_vaults
search_documentation
9/9 passing latest checkself-healing
Endpoints
9
Updated
18d ago

What is the Centrifuge API?

This API exposes 9 endpoints covering both the Centrifuge documentation site and the Centrifuge on-chain protocol data. You can retrieve full documentation page content, search across docs via search_documentation, navigate the site hierarchy, and query live protocol data — including pools, share class tokens, ERC-4626 vaults, investor transactions, and token positions — directly through typed GraphQL endpoints or a freeform graphql_query endpoint.

Try it
Full URL of the documentation page to fetch (e.g. 'https://docs.centrifuge.io/user/concepts/pools/') or a relative path (e.g. 'user/concepts/pools/').
api.parse.bot/scraper/bb03b46f-ab3f-4de4-a249-1eda193ee1e3/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/bb03b46f-ab3f-4de4-a249-1eda193ee1e3/get_page_content?url=https%3A%2F%2Fdocs.centrifuge.io%2Fdeveloper%2Fcentrifuge-api%2F' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace docs-centrifuge-io-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

"""Walkthrough: Centrifuge SDK — documentation, navigation, GraphQL, and protocol data."""
from parse_apis.Centrifuge_Documentation___Protocol_API import (
    Centrifuge, Pool, Token, Vault, SearchHit, InvestorTransaction,
    SiteNavigation, GraphqlResponse, NotFoundError
)

centrifuge = Centrifuge()

# Retrieve site navigation and count all documentation pages
nav = centrifuge.site_navigations.get()
print(f"Total documentation pages: {len(nav.all_urls)}")

# Search documentation for a topic
for hit in centrifuge.search_hits.search(query="vaults", limit=3):
    print(hit.url, hit.type, hit.hierarchy)

# Fetch a specific documentation page
page = centrifuge.pages.get(url="https://docs.centrifuge.io/user/concepts/pools/")
print(page.title, page.url)
for section in page.sections[:3]:
    print(section.level, section.title)

# List protocol pools and inspect their tokens
for pool in centrifuge.pools.list(limit=3):
    print(pool.id, pool.name, pool.is_active)
    for token in pool.tokens:
        print("  token:", token.id, token.symbol)

# List share class tokens with pricing info
token = centrifuge.tokens.list(limit=1).first()
if token:
    print(token.id, token.symbol, token.token_price, token.decimals)

# List vaults across blockchains
for vault in centrifuge.vaults.list(limit=3):
    print(vault.id, vault.blockchain_name, vault.chain_id, vault.is_active)

# List investor transactions
for tx in centrifuge.investor_transactions.list(limit=2):
    print(tx.created_at_tx_hash, tx.type, tx.token_amount)

# Typed error handling on page fetch
try:
    detail = centrifuge.pages.get(url="https://docs.centrifuge.io/user/concepts/pools/")
    print(detail.title, len(detail.code_blocks), "code blocks")
except NotFoundError as exc:
    print(f"page not found: {exc}")

print("exercised: site_navigations.get / search_hits.search / pages.get / pools.list / tokens.list / vaults.list / investor_transactions.list")
All endpoints · 9 totalmissing one? ·

Fetch the full content of any documentation page by URL. Parses the page HTML and returns the title, full text, structured sections with headings and content, code blocks, and tables. The page must exist on docs.centrifuge.io; relative paths are resolved against the base URL.

Input
ParamTypeDescription
urlrequiredstringFull URL of the documentation page to fetch (e.g. 'https://docs.centrifuge.io/user/concepts/pools/') or a relative path (e.g. 'user/concepts/pools/').
Response
{
  "type": "object",
  "fields": {
    "url": "string, the resolved URL of the page",
    "text": "string, full text content of the page",
    "title": "string, page title from the h1 heading",
    "tables": "array of arrays, each table as rows of cell text values",
    "sections": "array of objects with level, title, id, and content for each heading section",
    "code_blocks": "array of strings, text content of each code block on the page"
  },
  "sample": {
    "data": {
      "url": "https://docs.centrifuge.io/user/concepts/pools/",
      "text": "Concepts\nPools\nOn this page\nPools\nA pool is the core structure...",
      "title": "Pools",
      "tables": [],
      "sections": [
        {
          "id": "what-is-a-pool",
          "level": "h2",
          "title": "What is a pool?​",
          "content": "A pool brings together everything needed..."
        }
      ],
      "code_blocks": []
    },
    "status": "success"
  }
}

About the Centrifuge API

Documentation Endpoints

The get_page_content endpoint accepts a full or relative URL from the docs.centrifuge.io domain and returns the page title, full text, structured sections (each with level, title, id, and content), extracted tables as row arrays, and code_blocks. This makes it straightforward to pull specific concept pages, integration guides, or reference material programmatically. The get_site_navigation endpoint returns both a nested navigation tree and a flat all_urls list covering every page in the documentation site. search_documentation runs a full-text search and returns hits containing url, content snippets, and hierarchy breadcrumbs useful for contextual lookup.

Protocol Data Endpoints

Five typed GraphQL convenience endpoints cover the main Centrifuge protocol objects. graphql_query_pools returns each pool's id, name, centrifugeId, isActive flag, and associated share class tokens. graphql_query_tokens adds token-level detail: symbol, totalIssuance, tokenPrice, and the underlying pool asset decimals. graphql_query_vaults exposes vault deployment details including assetAddress, poolId, tokenId, status, and blockchain context. All three support limit and offset for pagination.

Investor Data and Custom Queries

graphql_query_investor_transactions returns transaction records with txHash, type, account, poolId, tokenAmount, currencyAmount, and createdAt. It accepts an optional account parameter (Ethereum address) to filter to a specific investor. graphql_query_investor_positions similarly accepts an account filter and returns tokenId, accountAddress, balance, isFrozen, and the token contract address. For queries beyond these prebuilt endpoints, graphql_query accepts an arbitrary GraphQL query string plus a JSON variables string — named operation syntax is required when passing variables.

Reliability & maintenanceVerified

The Centrifuge API is a managed, monitored endpoint for docs.centrifuge.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when docs.centrifuge.io changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official docs.centrifuge.io API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Last verified
3d ago
Latest check
9/9 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Monitor active Centrifuge pools and their share class tokens by polling graphql_query_pools for isActive status changes.
  • Build an investor dashboard by querying graphql_query_investor_transactions and graphql_query_investor_positions filtered by Ethereum account address.
  • Index the full Centrifuge documentation site for an internal knowledge base using get_site_navigation to enumerate URLs then get_page_content to extract text and sections.
  • Surface relevant Centrifuge protocol concepts in a developer tool by running search_documentation queries and returning ranked content snippets.
  • Track vault deployment status across blockchains by polling graphql_query_vaults for status and isActive changes per poolId.
  • Fetch token price and total issuance data for Centrifuge share classes via graphql_query_tokens for yield or NAV calculations.
  • Run ad-hoc protocol analytics by sending custom GraphQL queries through graphql_query with structured variables.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo1005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min

One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does Centrifuge have an official developer API?+
Yes. Centrifuge operates an official GraphQL API for protocol data, documented at https://docs.centrifuge.io. The Parse API provides typed convenience endpoints over that protocol API alongside documentation retrieval endpoints.
What does `graphql_query_investor_transactions` return and how do I filter by investor?+
It returns an array of transaction objects, each with txHash, type, account, poolId, tokenAmount, currencyAmount, and createdAt. Pass an Ethereum address as the optional account parameter to filter results to a single investor's activity.
Does `graphql_query_vaults` return historical vault state or only current status?+
Each vault item reflects its current status and isActive flag at query time. Historical vault state changes are not exposed through this endpoint. You can fork the API on Parse and revise it to add a time-series or event-log endpoint if historical state tracking is needed.
Can I retrieve pool NAV or loan-level asset data through the pool endpoints?+
Not currently. graphql_query_pools returns pool identity fields (id, name, centrifugeId, isActive) and token associations, not NAV calculations or individual loan records. You can fork the API on Parse and revise it to add a custom graphql_query call that targets loan or NAV fields from the Centrifuge protocol GraphQL schema.
Are there pagination controls on the protocol data endpoints?+
The pool, token, and vault endpoints each accept limit and offset integer parameters. The investor transaction and position endpoints accept limit but not offset — use the account filter to narrow results rather than paginating through a full dataset.
Page content last updated . Spec covers 9 endpoints from docs.centrifuge.io.
Related APIs in Crypto Web3See all →
soliditylang.org API
Access comprehensive Solidity documentation, search language references, and browse blog posts to stay updated on development news. Query compiler bug data filtered by version to identify known issues and compatibility concerns across smart contract projects.
developers.notion.com API
Search and browse Notion's developer documentation to find specific pages and retrieve their full content in markdown format. Access comprehensive information about Notion's capabilities by listing available pages or looking up individual documentation entries.
studio.glassnode.com API
Access comprehensive on-chain and market analytics for cryptocurrencies, including asset fundamentals, supply dynamics, futures data, and profit/loss metrics. Search and analyze assets with historical chart data and market overview information to track crypto performance and trends.
Docs.copia.io API
Search and browse the complete Copia Automation documentation, discover available pages, and retrieve full text content from any page on docs.copia.io. Quickly find answers by searching documentation content or accessing specific guides and references.
deepwiki.com API
Search and retrieve documentation for any GitHub repository indexed on DeepWiki, including wiki pages, table of contents, and source file references in markdown format. Look up repository profiles, discover featured projects, and access complete wiki content all in one place.
vfat.io API
Track yield farming opportunities, compare token liquidity and lending rates across 30+ blockchains, and monitor your DeFi portfolio performance in real-time. Analyze farm details, platform statistics, and market data to make informed decisions about where to deploy your assets.
airdrops.io API
Discover and track crypto airdrops in real-time by browsing latest opportunities, searching by category, and viewing detailed project information including participation requirements and token details. Monitor live cryptocurrency prices and stay updated on hot and potential airdrops all in one place.
moondev.com API
Access live crypto market data from MoonDev's public endpoints: aggregated Hyperliquid positions near liquidation, fees leaderboard, PnL share stats by address, Polymarket sweep trades, and soon-to-expire Polymarket markets — plus a single aggregate endpoint that pulls all major datastreams at once.