Binance Smart Chain - Build on Coinbase's Ethereum Layer 2

Binance Smart Chain RPC
With Dwellir, you get access to our global Binance Smart Chain network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key →

Why Build on Binance Smart Chain?

Binance Smart Chain is Coinbase's Ethereum Layer 2 solution, designed to bring the next billion users onchain. Built on Optimism's OP Stack, Binance Smart Chain offers:

🚀 Lightning Fast Performance

• Sub-second block times - Get near-instant transaction confirmations
• 10-100x lower costs than Ethereum mainnet
• EIP-4844 enabled - Leveraging blob data for even lower fees

🛡️ Enterprise Security

• Backed by Coinbase - Institutional-grade infrastructure
• Ethereum security - Inherits L1 security guarantees
• Battle-tested - Built on proven Optimism technology

🌍 Massive Ecosystem

• 1M+ weekly active users - Rapidly growing user base
• $2B+ TVL - Strong DeFi ecosystem
• Major integrations - Circle USDC, Chainlink, The Graph

Quick Start with Binance Smart Chain

Connect to Binance Smart Chain in seconds with Dwellir's optimized endpoints:

🔗 RPC Endpoints

Binance Smart Chain Mainnet (Chain ID: 56)Live

https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY

✓ Full Node✓ Debug API✓ WebSocket

Quick Connect:

curl -X POST https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Installation & Setup

Ethers.js v6

import { JsonRpcProvider } from 'ethers';

// Connect to BSC mainnet
const provider = new JsonRpcProvider(
  'https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY'
);

// Get the latest block
const block = await provider.getBlock('latest');
console.log('Latest block:', block.number);

// Query account balance
const balance = await provider.getBalance('0x...');
console.log('Balance:', balance.toString());

Web3.js

const Web3 = require('web3');

// Connect to BSC mainnet
const web3 = new Web3(
  'https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY'
);

// Get chain ID to verify connection
const chainId = await web3.eth.getChainId();
console.log('Connected to BSC:', chainId === 56);

// Get gas price for optimal transaction pricing
const gasPrice = await web3.eth.getGasPrice();
console.log('Current gas price:', gasPrice);

Viem

import { createPublicClient, http } from 'viem';
import { bsc } from 'viem/chains';

// Create BSC client
const client = createPublicClient({
  chain: bsc,
  transport: http('https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY'),
});

// Read contract data
const data = await client.readContract({
  address: '0x...',
  abi: contractAbi,
  functionName: 'balanceOf',
  args: ['0x...'],
});

Network Information

Chain ID

56

Mainnet

Block Time

3 seconds

Average

Gas Token

ETH

Native token

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference

Binance Smart Chain supports the full Ethereum JSON-RPC API specification. Access all standard methods plus L2-specific optimizations.

Available JSON-RPC Methods

📊 Reading Blockchain Data

Query blocks, transactions, and account states

+

📤 Sending Transactions

Submit and manage transactions

+

📝 Smart Contract Interaction

Call and interact with smart contracts

+

🔧 Node & Network Info

Query node status and network information

+

Ready to build on Binance Smart Chain?

Get your API key →

Common Integration Patterns

🔄 Transaction Monitoring

Monitor pending and confirmed transactions efficiently:

// Watch for transaction confirmation
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);
  
  if (receipt.l1Fee) {
    console.log('L1 data cost:', receipt.l1Fee);
  }
  
  return receipt;
}

💰 Gas Optimization

Optimize gas costs on Binance Smart Chain:

// Estimate L2 execution gas
const l2Gas = await provider.estimateGas(tx);

// Get current L1 data fee (Base specific)

// Total cost = L2 execution + L1 data posting
const totalCost = l2Gas + BigInt(l1DataFee);

🔍 Event Filtering

Efficiently query contract events:

// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 2000; // Base recommended batch size
  
  for (let i = fromBlock; i <= currentBlock; i += batchSize) {
    const batch = await contract.queryFilter(
      filter, 
      i, 
      Math.min(i + batchSize - 1, currentBlock)
    );
    events.push(...batch);
  }
  
  return events;
}

Performance Best Practices

1. Batch Requests

Combine multiple RPC calls for optimal performance:

const batch = [
  { method: 'eth_blockNumber', params: [] },
  { method: 'eth_gasPrice', params: [] },
  { method: 'eth_getBalance', params: [address, 'latest'] }
];

const results = await provider.send(batch);

2. Connection Pooling

Reuse provider instances to minimize connection overhead:

// Singleton pattern for provider
class BSCProvider {
  static instance = null;
  
  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY'
      );
    }
    return this.instance;
  }
}

3. Smart Caching

Cache immutable data to reduce API calls:

const cache = new Map();

async function getCachedBlockData(blockNumber) {
  const key = `block_${blockNumber}`;
  
  if (!cache.has(key)) {
    const block = await provider.getBlock(blockNumber);
    cache.set(key, block);
  }
  
  return cache.get(key);
}

Troubleshooting Common Issues

Error: "Insufficient funds for L1 fee"

Binance Smart Chain transactions require ETH for both L2 execution and L1 data availability:

// Always account for L1 fees in balance checks
const balance = await provider.getBalance(address);
const l2Gas = await provider.estimateGas(tx);
const totalRequired = l2Gas + BigInt(l1Fee) + tx.value;

if (balance < totalRequired) {
  throw new Error(`Need ${totalRequired - balance} more ETH`);
}

Error: "Transaction underpriced"

Binance Smart Chain uses EIP-1559 pricing. Always use dynamic gas pricing:

// Get current fee data
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
  gasLimit: 21000n
};

Error: "Rate limit exceeded"

Implement exponential backoff for resilient applications:

async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 2 ** i * 1000));
      } else {
        throw error;
      }
    }
  }
}

Migration Guide

From Ethereum Mainnet

Moving from L1 to Binance Smart Chain requires minimal changes:

// Before (Ethereum)
const provider = new JsonRpcProvider('https://eth-rpc.example.com');

// After (BSC)
const provider = new JsonRpcProvider(
  'https://api-bsc-mainnet-full.n.dwellir.com/YOUR_API_KEY'
);

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ⚠️ Different chain ID (56)
// ⚠️ Separate block numbers
// ⚠️ Different gas token (BNB instead of ETH)

Resources & Tools

Official Resources

• Binance Smart Chain Documentation
• Binance Smart Chain Bridge
• Binance Smart Chain Block Explorer

Developer Tools

• Hardhat Config
• Foundry Setup
• Truffle Integration

Need Help?

• 📧 Email: support@dwellir.com
• 📚 Docs: You're here!
• 🎯 Dashboard: dashboard.dwellir.com

---

Start building on Binance Smart Chain with Dwellir's enterprise-grade RPC infrastructure. Get your API key →