# Centrifuge RPC Documentation

## Centrifuge RPC plans and rate limits

- **Free plan:** 20 responses per second, up to 100,000 responses a day.
- **Plans:** $49/mo, $299/mo, $999/mo with 25M, 150M, and 500M included responses. Overages billed at $5/$3/$2 per million responses respectively.
- **Paid rate limits:** 100 to 5,000 responses per second (bursts from 500 to 10,000), no daily limit.
- **Billing:** 1 response = 1 API credit on every shared plan, over HTTPS or WebSocket (WSS) where Centrifuge supports it.

Details: [Pricing](https://www.dwellir.com/docs/getting-started/pricing) · [Rate limits](https://www.dwellir.com/docs/getting-started/rate-limits) · [Authentication](https://www.dwellir.com/docs/getting-started/authentication) · [Archive nodes](https://www.dwellir.com/docs/getting-started/archive-nodes)

## Overview

Centrifuge is the leading Real-World Asset (RWA) protocol and Polkadot parachain, providing infrastructure for tokenizing, managing, and investing in real-world financial assets. Built on the Substrate framework, Centrifuge bridges traditional finance with DeFi, enabling businesses to access instant, bankless liquidity through tokenized credit, real estate, treasuries, and other real-world assets.

This documentation provides comprehensive coverage of Centrifuge's JSON-RPC API methods, enabling developers to interact with Centrifuge nodes for building applications, wallets, explorers, and other blockchain tools.

## Network Information

### Mainnet (Centrifuge)

| Parameter      | Value                                                              | Details |
| -------------- | ------------------------------------------------------------------ | ------- |
| Parachain ID   | 2031                                                               |         |
| Native Token   | CFG                                                                |         |
| Token Decimals | 18                                                                 |         |
| SS58 Prefix    | 36                                                                 |         |
| Consensus      | Nominated Proof-of-Stake (NPoS) via Polkadot                       |         |
| Framework      | Substrate                                                          |         |
| Genesis Hash   | 0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82 |         |

## Connection Endpoints

### HTTPS Endpoint

```
https://api-centrifuge.n.dwellir.com/{YOUR_API_KEY}
```

### WebSocket Endpoint

```
wss://api-centrifuge.n.dwellir.com/{YOUR_API_KEY}
```

## Authentication

Authentication is done via the URL path. Replace `{YOUR_API_KEY}` with your actual API key obtained from [dwellir.com](https://www.dwellir.com).

## API Categories

Centrifuge's RPC API is organized into the following method categories:

### Core APIs

#### Author Methods

Submit and manage extrinsics (transactions) on the network.

#### Chain Methods

Query blockchain data including blocks, headers, and finalized state.

#### State Methods

Access runtime storage, metadata, and proof generation.

#### System Methods

Node information, health checks, and network properties.

### Specialized APIs

#### BEEFY Methods

Bridge Efficiency Enabling Finality Yielder protocol operations.

#### Grandpa Methods

GRANDPA finality gadget operations and proofs.

#### Child State Methods

Manage child storage tries for contracts and parachains.

#### Sync State Methods

Monitor and manage node synchronization state.

## Quick Start Examples

### Get Latest Block

```javascript
const response = await fetch('https://api-centrifuge.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'chain_getBlock',
    params: [],
    id: 1
  })
});

const data = await response.json();
console.log('Latest block:', data.result);
```

### Submit Transaction

```python
import requests
import json

url = "https://api-centrifuge.n.dwellir.com/YOUR_API_KEY"
headers = {
    "Content-Type": "application/json"
}

# Properly formatted and signed extrinsic
extrinsic = "0x..."

payload = {
    "jsonrpc": "2.0",
    "method": "author_submitExtrinsic",
    "params": [extrinsic],
    "id": 1
}

response = requests.post(url, headers=headers, data=json.dumps(payload))
tx_hash = response.json()["result"]
print(f"Transaction hash: {tx_hash}")
```

### Subscribe to New Blocks (WebSocket)

```javascript
const WebSocket = require('ws');

const ws = new WebSocket('wss://api-centrifuge.n.dwellir.com/YOUR_API_KEY');

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    method: 'chain_subscribeNewHeads',
    params: [],
    id: 1
  }));
});

ws.on('message', (data) => {
  const response = JSON.parse(data);
  if (response.params?.result) {
    console.log('New block:', response.params.result);
  }
});
```

## Error Handling

Centrifuge RPC errors follow the JSON-RPC 2.0 error format:

```json
{
  "jsonrpc": "2.0",
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": "Expected hex-encoded hash"
  },
  "id": 1
}
```

### Common Error Codes

| Code   | Message          | Description               |
| ------ | ---------------- | ------------------------- |
| -32700 | Parse error      | Invalid JSON              |
| -32600 | Invalid request  | Missing required fields   |
| -32601 | Method not found | Unknown RPC method        |
| -32602 | Invalid params   | Invalid method parameters |
| -32603 | Internal error   | Node processing error     |
| -32000 | Server error     | Custom server errors      |

## Best Practices

### 1. Connection Management

- Use WebSocket connections for subscriptions and real-time updates
- Implement reconnection logic for WebSocket disconnections
- Use HTTPS for single queries and transactions

### 2. Error Handling

- Always check for error responses before processing results
- Implement retry logic with exponential backoff
- Log errors for debugging and monitoring

### 3. Performance Optimization

- Batch multiple queries when possible
- Cache frequently accessed data like metadata
- Use specific block hashes for deterministic queries

### 4. Security

- Never expose API keys in client-side code
- Validate all input data before submission
- Use secure storage for private keys

## SDK Support

### Official Libraries

- **@polkadot/api** - JavaScript/TypeScript SDK (compatible with Centrifuge)
- **py-substrate-interface** - Python SDK
- **subxt** - Rust SDK
- **go-substrate-rpc-client** - Go SDK

### Integration Example

```javascript
// Using @polkadot/api
const { ApiPromise, WsProvider } = require('@polkadot/api');

async function connect() {
  const provider = new WsProvider('wss://api-centrifuge.n.dwellir.com/YOUR_API_KEY');

  const api = await ApiPromise.create({ provider });

  // Query chain data
  const chain = await api.rpc.system.chain();
  console.log(`Connected to ${chain}`);

  // Get account balance
  const account = 'YOUR_ADDRESS';
  const { data: balance } = await api.query.system.account(account);
  console.log(`Balance: ${balance.free.toString()}`);

  return api;
}
```

## Centrifuge Features

### Real-World Asset Tokenization

Centrifuge is the leading protocol for tokenizing real-world assets, with $270 million in active loans and nearly $500 million in total financed assets. The platform enables:

- **Private Credit** - Tokenization of private credit and lending markets
- **Real Estate** - Property-backed tokenized assets
- **Treasuries** - Government bond tokenization
- **Invoice Financing** - SME invoice and receivables tokenization

### DeFi Integration

Centrifuge bridges traditional finance with DeFi through:

- **Multichain Support** - Integration across Polkadot, Ethereum, and other chains via Wormhole
- **Liquidity Pools** - Tinlake protocol for asset-backed lending pools
- **Institutional Grade** - Compliance-ready infrastructure for regulated assets

### CFG Token

The CFG token serves multiple purposes:

- **Governance** - Community-driven protocol upgrades and parameter changes
- **Staking** - Network security through Polkadot's NPoS
- **Utility** - Access to protocol features and services

### Polkadot Integration

As a Polkadot parachain, Centrifuge benefits from:

- **Shared Security** - Protected by Polkadot's validator network
- **Cross-Chain Interoperability** - Seamless communication with other parachains
- **Scalability** - Leveraging Polkadot's multi-chain architecture

## Additional Resources

- [Centrifuge Website](https://centrifuge.io/)
- [Centrifuge Documentation](https://docs.centrifuge.io/)
- [Centrifuge GitHub](https://github.com/centrifuge)
- [Centrifuge Explorer](https://centrifuge.subscan.io/)
- [Polkadot Parachains Info](https://parachains.info/details/centrifuge)
- [Substrate Documentation](https://docs.substrate.io/)

## Support

For additional support or questions:

- Email: <support@dwellir.com>
- Documentation: [dwellir.com/docs](https://www.dwellir.com/docs)

***

## Method Categories

Select a category below to explore detailed method documentation:
