Flare RPC Node
Blockchain for Data

Q: What is Flare Network?

Flare is an EVM-compatible Layer 1 blockchain designed for decentralized data acquisition. It provides native oracle and cross-chain data protocols without relying on external services.

Q: What is the Flare Time Series Oracle (FTSO)?

FTSO is Flare's decentralized oracle providing price feeds for crypto assets. Data providers submit prices, which are aggregated on-chain to produce trustless, manipulation-resistant feeds.

Q: What is the State Connector?

State Connector is a protocol that enables Flare smart contracts to verify events and state from external blockchains like Bitcoin, Dogecoin, and XRP Ledger in a trustless manner.

Q: Are FTSO price feeds free to use?

Yes, FTSO price feeds are available on-chain without fees. This is a key differentiator from traditional oracle solutions like Chainlink that charge per query.

Q: What chains can Flare connect to?

Flare's State Connector supports Bitcoin, Dogecoin, XRP Ledger, Litecoin, and Algorand, with plans to expand to more chains. This enables trustless cross-chain applications.

Q: Is Flare EVM compatible?

Yes, Flare is fully EVM-compatible. You can deploy Solidity contracts and use all Ethereum development tools like MetaMask, Hardhat, Remix, and ethers.js.

Q: How do I get FLR tokens?

FLR can be acquired on exchanges or by participating in Flare's delegation system. You can also bridge assets to Flare using LayerCake or other cross-chain bridges.

Q: What is Songbird?

Songbird is Flare's canary network — a live testing environment where new features are deployed before Flare mainnet. It has its own token (SGB) and full functionality.

Q: Do you support Flare testnet?

Yes, we provide RPC access to both Flare mainnet (Chain ID 14) and Coston2 testnet (Chain ID 114) for development and testing.

Q: How can I become an FTSO data provider?

FTSO data providers run infrastructure to submit price data and earn rewards. It requires technical setup, FLR stake, and reliable data sources. Details at flare.network.

Connect to Flare, the blockchain built for decentralized data acquisition. Access trustless price feeds, cross-chain data, and state connector protocols for advanced DeFi applications.

Documentation Get a free endpoint

4 M+

Requests per Day

99.9 %

Network Uptime

< 100 ms

Average Response Time

24/7

Technical Support

Specification Flare Network

Technical characteristics and available endpoints

Flare (FLR)

Mainnet & Testnet Support — Coston2

Chain ID 14

Protocol HTTPS / WSS

Uptime 99.9%

Block Time ~1.8s

Consensus Federated Byzantine Agreement

EVM Compatible Yes

Flare is a blockchain designed for data — providing decentralized access to high-integrity price feeds, cross-chain information, and Web2 APIs through native protocols. Built as an EVM-compatible Layer 1, Flare enables developers to build data-dependent applications without relying on centralized oracles or bridges.

Key capabilities:

Flare Time Series Oracle (FTSO) — decentralized price feeds
State Connector — trustless cross-chain data verification
LayerCake bridge — secure cross-chain asset transfers
Full EVM compatibility with Solidity support
Native integration with XRP Ledger, Dogecoin, and other chains
Built-in data acquisition protocols at the consensus layer
Fast finality with 1.8-second block time

🔗 RPC Endpoints

HTTPS

https://rpc.crypto-chief.com/flare/{YOUR_API_KEY}

WSS

wss://rpc.crypto-chief.com/flare/ws/{YOUR_API_KEY}

Replace {YOUR_API_KEY} with your actual API key from the dashboard.

What is a Flare RPC Node?

Access blockchain-native data infrastructure

A Flare RPC node provides applications with access to Flare's unique data-acquisition protocols alongside standard blockchain operations. Flare enables developers to build applications that rely on trustless price feeds, cross-chain data, and Web2 API access without centralized intermediaries.

What makes Flare unique

Unlike traditional blockchains that require external oracles for off-chain data, Flare builds data acquisition directly into its consensus layer. The Flare Time Series Oracle (FTSO) and State Connector protocols provide decentralized, trustless access to price feeds and cross-chain information, enabling entirely new categories of DeFi applications.

Flare advantages:

Native oracles — FTSO provides decentralized price feeds on-chain
Cross-chain data — State Connector verifies external blockchain states
No oracle fees — data acquisition built into protocol
EVM compatible — full Solidity and Ethereum tooling support
Fast finality — 1.8s blocks with quick confirmations
Multi-chain focus — native integration with non-smart contract chains

Flare's data protocols

FTSO (Flare Time Series Oracle) is a decentralized price oracle where independent data providers submit price data, which is aggregated through weighted median to produce trustless price feeds for assets like BTC, ETH, XRP, and more.

State Connector enables smart contracts on Flare to verify events and state from external blockchains (Bitcoin, Dogecoin, XRP Ledger) in a decentralized manner, enabling trustless cross-chain applications.

How Flare works:

Data providers submit price feeds and proofs to Flare
Validators aggregate data through consensus mechanisms
Smart contracts access verified data on-chain without fees
State Connector proves external blockchain events
Applications build on trustless, decentralized data

RPC access methods

HTTPS endpoints handle standard EVM operations plus Flare-specific calls for FTSO data, State Connector proofs, and cross-chain verification.

WebSocket endpoints enable real-time subscriptions to FTSO price updates, State Connector attestations, and new block notifications.

Technical Documentation

Quick start for developers

Supported RPC Methods

Flare supports standard Ethereum JSON-RPC methods plus Flare-specific extensions for data protocols:

eth_blockNumber — current block number
eth_getBalance — FLR balance
eth_call — call contract functions
eth_sendRawTransaction — submit transactions
eth_getTransactionReceipt — transaction status
eth_getLogs — event logs including FTSO updates
eth_gasPrice — current gas price
eth_estimateGas — gas estimation
eth_subscribe — WebSocket subscriptions

Code Examples

💻

JavaScript (ethers.js) — Access FTSO Price Feed:

const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider('https://rpc.crypto-chief.com/flare/YOUR_API_KEY');

// Verify network
const network = await provider.getNetwork();
console.log('Chain ID:', network.chainId); // 14

// Access FTSO price feed for BTC/USD
const FTSO_REGISTRY = '0x1000000000000000000000000000000000000003';
const ftsoABI = [
  'function getCurrentPriceWithDecimals(string) view returns (uint256, uint256, uint256)'
];
const ftso = new ethers.Contract(FTSO_REGISTRY, ftsoABI, provider);

const [price, timestamp, decimals] = await ftso.getCurrentPriceWithDecimals('BTC');
console.log('BTC Price:', Number(price) / Math.pow(10, Number(decimals)));
console.log('Timestamp:', new Date(Number(timestamp) * 1000));

💻

Python (web3.py) — Flare FTSO Integration:

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://rpc.crypto-chief.com/flare/YOUR_API_KEY'))

print('Connected to Flare:', w3.is_connected())
print('Chain ID:', w3.eth.chain_id)  # 14

# Access FTSO for ETH price
FTSO_REGISTRY = '0x1000000000000000000000000000000000000003'
ftso_abi = [{'constant':True,'inputs':[{'name':'_symbol','type':'string'}],'name':'getCurrentPriceWithDecimals','outputs':[{'name':'_price','type':'uint256'},{'name':'_timestamp','type':'uint256'},{'name':'_decimals','type':'uint256'}],'type':'function'}]

ftso = w3.eth.contract(address=FTSO_REGISTRY, abi=ftso_abi)
price, timestamp, decimals = ftso.functions.getCurrentPriceWithDecimals('ETH').call()
print(f'ETH Price: ${price / 10**decimals}')

💻

WebSocket — Monitor FTSO Price Updates:

const { ethers } = require('ethers');
const provider = new ethers.WebSocketProvider('wss://rpc.crypto-chief.com/flare/ws/YOUR_API_KEY');

// Monitor FTSO price reveal events
const FTSO_MANAGER = '0x1000000000000000000000000000000000000003';
const filter = {
  address: FTSO_MANAGER,
  topics: [ethers.id('PriceRevealed(string,uint256,uint256)')]
};

provider.on(filter, (log) => {
  console.log('New FTSO price revealed:', log);
});

// Monitor new blocks
provider.on('block', (blockNumber) => {
  console.log('New Flare block:', blockNumber);
});

Flare-Specific Features

FTSO Access: Free on-chain price feeds without oracle fees
State Connector: Verify Bitcoin, Dogecoin, XRP transactions on Flare
LayerCake Bridge: Secure cross-chain asset transfers
Delegation: Delegate FLR to data providers for rewards
Native Tokens: Wrapped BTC, DOGE, XRP, LTC on Flare
FastUpdates: Sub-block price feed updates for trading

Why choose us?

Reliable infrastructure for data-dependent applications

Data-Optimized

Infrastructure optimized for FTSO data queries, State Connector proofs, and high-frequency price feed access with caching.

Secure & Reliable

Enterprise-grade security with TLS encryption, DDoS protection, and 99.9% uptime for mission-critical data applications.

Analytics Dashboard

Monitor RPC usage, FTSO queries, State Connector calls, and performance metrics through comprehensive analytics.

Global Network

Strategically deployed nodes across regions ensuring low-latency access to Flare's data protocols worldwide.

Auto-Scaling

Infrastructure scales automatically during high FTSO query volumes maintaining consistent performance.

Expert Support

24/7 support from engineers familiar with Flare's unique data protocols, FTSO, and State Connector architecture.

Examples of Use

Build data-powered applications on Flare

Flare's native data acquisition protocols enable entirely new categories of blockchain applications — from DeFi without oracle fees to trustless cross-chain bridges and prediction markets with verifiable outcomes.

Oracle-Free DeFi

Build lending, derivatives, and trading protocols using FTSO price feeds without paying oracle fees. Access decentralized price data for 100+ asset pairs directly on-chain.

Cross-Chain Applications

Leverage State Connector to verify Bitcoin, Dogecoin, and XRP transactions on Flare. Build trustless bridges and cross-chain protocols without centralized relayers.

Prediction Markets

Create prediction markets and betting platforms using verifiable FTSO data and State Connector proofs for event resolution without trusted intermediaries.

DEX & Trading Platforms

Build decentralized exchanges with real-time FTSO price feeds. Our infrastructure supports high-frequency price queries for trading interfaces and bots.

Insurance Protocols

Develop parametric insurance using State Connector to verify real-world events and FTSO for pricing. Trustless claim settlement based on blockchain-verified data.

Analytics & Data Services

Build analytics platforms leveraging Flare's rich data ecosystem. Access historical FTSO prices, cross-chain transaction verification, and on-chain data aggregation.

Got questions?
we are here to help