Cloud RPC API

Prerequisites

Before continuing, an account is required for access. If you already have an API key, however, you may skip this step.

First, please register or log in at https://cloud.developerdao.com. Next, In the center of the dashboard page, click the gray button that says “manage API keys”. Lastly, click the white button that says “Generate New API Key” and copy the newly generated key from the table below.

JSON-RPC

Sends a JSON-RPC call to the CHAIN_ID.

https://api.cloud.developerdao.com/rpc/{CHAIN_ID}/{API_KEY}

Websockets

Initiates a websocket connection to CHAIN_ID

wss://api.cloud.developerdao.com/ws/{CHAIN_ID}/{API_KEY}

Parameters

There are two parameters required on each path of the RPC service: a chain id and an api key.

Parameter	Description	Type	Optional
CHAIN_ID	Routes your request to the chain you want to use	Path	False
API_KEY	The user’s API key obtained from the dashboard. Used for auth and tracking resource consumption.	Path	False

Supported Chain IDS

ID	WS Support
eth	false
base	true
arb-one	false
solana	false
sui	false
bsc	true
poly	false
op	false

Get Started with D_D Cloud RPC

Welcome to D_D Cloud RPC! This guide will get you up and running in under 5 minutes. Follow along to make your first blockchain request and start building amazing dApps.

Making Your First Request

Prerequisites

Before you begin, make sure you have:

A D_D Cloud account (free signup)
Basic knowledge of your preferred programming language
Internet connection for API requests

Step 1: Get Your API Key

If you already created an API key, you should find it here. Otherwise, proceed to the sub-section below.

Create Your API Key

Sign in to your D_D Cloud Account
Navigate to Manage API Keys in the center of the dashboard page
Click Generate New Key
Copy and securely store your API key

Caution

Take the pledge by Patrick Collins

do not hardcode secrets into your code
do not store secrets in plaintext

Step 2: Install Dependencies

Choose your preferred language and install the required packages:

npm install ethers

pip install web3

cargo add alloy tokio --features alloy/full,tokio/full

Step 3: Make Your First Request

Now let’s fetch the latest finalized block from Ethereum. Replace YOUR_API_KEY_GOES_HERE with your actual API key:

import { ethers } from "ethers";

async function main() {
  const provider = new ethers.JsonRpcProvider(
    `https://api.cloud.developerdao.com/rpc/eth/YOUR_API_KEY_GOES_HERE`
  );

  try {
    // Get the most recent finalized block
    const block = await provider.getBlock("finalized");
    
    // Log the block details
    console.log("✅ Most recent, finalized block:", {
      number: block.number,
      hash: block.hash,
      timestamp: new Date(block.timestamp * 1000).toISOString(),
      transactions: block.transactions.length
    });
  } catch (error) {
    console.error("❌ Error fetching block:", error.message);
  }
}

main();

Python

from web3 import Web3
from datetime import datetime

def main():
    # Initialize Web3 with D_D Cloud RPC endpoint
    provider_url = "https://api.cloud.developerdao.com/rpc/eth/YOUR_API_KEY_GOES_HERE"
    web3 = Web3(Web3.HTTPProvider(provider_url))
    
    try:
        # Check connection
        if not web3.is_connected():
            raise Exception("Failed to connect to D_D Cloud RPC")
            
        # Get the most recent finalized block
        block = web3.eth.get_block('finalized')
        
        # Log the block details
        print("✅ Most recent, finalized block:", {
            "number": block.number,
            "hash": block.hash.hex(),
            "timestamp": datetime.fromtimestamp(block.timestamp).isoformat(),
            "transactions": len(block.transactions)
        })
    except Exception as error:
        print(f"❌ Error fetching block: {error}")

if __name__ == "__main__":
    main()

use alloy::{
    eips::BlockId,
    providers::{Provider, ProviderBuilder},
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = ProviderBuilder::new()
        .on_http("https://api.cloud.developerdao.com/rpc/eth/YOUR_API_KEY_GOES_HERE"
            .parse()?);
    
    match provider.get_block(BlockId::finalized()).await {
        Ok(Some(block)) => {
            println!("✅ Most recent, finalized block:");
            println!("  Number: {:?}", block.header.number);
            println!("  Hash: {:?}", block.header.hash);
            println!("  Timestamp: {:?}", block.header.timestamp);
            println!("  Transactions: {}", block.transactions.len());
        }
        Ok(None) => println!("❌ Block not found"),
        Err(e) => println!("❌ Error fetching block: {}", e),
    }
    
    Ok(())
}

cURL

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByNumber",
    "params": ["finalized", true],
    "id": 1
  }' \
  https://api.cloud.developerdao.com/rpc/eth/YOUR_API_KEY_GOES_HERE

What’s Next?

Deploy Your First dApp: Learn to build and deploy a complete decentralized application using D_D Cloud RPC. Start Building →
Explore All Networks: Discover 50+ supported blockchain networks including Ethereum, Polygon, Arbitrum, and more. View Networks →
Advanced Features: WebSockets, batch requests, archive data, and performance optimization techniques. Learn More →
API Reference: Complete documentation of all available RPC methods and parameters. View Docs →
Join Community: Connect with other developers, get help, and share your projects with the D_D community. Join Discord →
Monitor Usage: Track your API usage, set up alerts, and optimize your applications for better performance. View Dashboard →

Keyboard shortcuts

D_D Cloud Docs