Pyth is an oracle "first-party": the original price data is self-reported by exchanges, market makers, financial institutions, etc., on the network, then aggregated and distributed multi-chain according to the pull oracle model (pulling price data when needed). As of July 2025, Pyth announced 125+ data providers, 1,930+ price feeds, 107+ connected blockchains, ~6.95M Entropy requests, $20.9B+ TVS, and 946M+ PYTH staked for OIS (Oracle Integrity Staking).
Note on the phrase 'no intermediaries needed': Pyth eliminates the 'node' that aggregates third-party data at the data source stage (as the providers publish prices themselves). However, the system still has intermediate infrastructure layers such as Pythnet (Solana-like appchain) and Wormhole to sign attestations and transfer data cross-chain.
⸻
Architecture & main components
• Publishers (Data Providers): CEX/DEX exchanges, MMs, financial institutions (e.g., Wintermute, Jane Street, Revolut…). They publish their own prices on Pyth.
• Pythnet (appchain): a dedicated chain (Solana-like) where prices are aggregated & normalized; each feed has a price, reliability (confidence interval), timestamp, etc.
• Aggregation & signature: Pyth uses an aggregation model that considers reliability/weights from multiple sources and creates an aggregated price along with a confidence interval.
• Wormhole + Hermes (Price Service): prices signed on Pythnet are packaged into attestations (VAA). Applications on EVM/SVM/... pull these updates (via Hermes) and update on-chain right at the moment of transaction need.
• Consuming contracts: your contract calls updatePriceFeeds + pays update fee then reads price via API like getPriceNoOlderThan.
⸻
The data flow of 'pull oracle' (5 steps)
1. Publishers push raw quotes to Pythnet.
2. Pythnet aggregates → creates price + confidence and signs.
3. Hermes serves signed 'price updates'.
4. In transactions, dApp pulls byte updates from Hermes → sends to the Pyth contract on the target chain (pays update fee).
5. dApp reads the price immediately after an update (check 'new enough' & confidence).
Advantages:
• Low latency, ultra-fast updates (sub-second; some documents state up to ~400ms/update).
• Pay-per-use (not every block pushes prices).
• Choose the timing of updates in trading logic, useful for derivatives/AMMs quick.
Trade-off:
• dApp must orchestrate the update step in transactions (if not, the price may become 'stale'). Pyth provides a Scheduler for automation.
⸻
Data model & safety
• Price + Confidence: Each feed returns a price and uncertainty (confidence interval) — this 'range' is used for risk management, e.g., widening margins during high volatility (liquidation, oracle protection…).
• Price status: Only used when status = trading; if Halted/Auction/Unknown, it should not be used directly.
• Secure cross-chain: Price updates carry signatures/attestation via Wormhole; Pyth contracts on the target chain verify the origin before writing.
• Oracle Integrity Staking (OIS): stake/slash mechanism to bind correct behavior of the oracle system; governance & fee allocation are determined by DAO. (Token allocation and OIS mechanisms are publicly described).
• Bug bounty: a large-scale bounty program aimed at encouraging the discovery of security vulnerabilities.
⸻
Performance & coverage (as of 07/2025)
• 1,930+ price feeds, 107+ chains, 125+ data providers; sub-second updates, and there is an Insights Hub/KPI dashboard to observe performance & coverage in real-time.
⸻
Fees & data economics
• Update Fee: the contract when calling price update pays an update fee (compensates for data transfer costs & infrastructure).
• Data Fees: the data protocol may incur data fees (designed to reward data providers and fund network operations). Parameters are adjusted by DAO governance.
• PYTH token: serves governance, OIS staking, and economic allocation processes. The official token allocation article outlines the schedule & allocation goals.
⸻
Supplementary product of Pyth
• Benchmarks (historical data): query signed historical prices (normalized) for backtesting, settling contracts, reporting…
• Entropy (on-chain RNG): fast & cheap randomness service with convenient callback for games/NFTs/lotteries… (docs + blog & integration guide).
• Express Relay: mechanism to push prices into blocks with priority & anti-MEV for latency-sensitive apps.
⸻
Quick comparison: Pyth vs traditional 'push oracle'
• Data sources: Pyth: first-party (publisher self-publishing); traditional: node operators collect from APIs/data gateways.
• Distribution mechanism: Pyth: pull on-demand → only pay when used, optimized for use cases needing 'just-in-time' pricing; push: prices are pushed on schedule every block/epoch (easier to use but sometimes less flexible/carries base fees).
• Latency: Pyth aims for sub-second / ~400ms; push is often slower due to update schedules. (The number ~400ms is mentioned in integration chain documents.)
⸻
Technical notes & best practices for integration
• Control 'staleness': use API getPriceNoOlderThan/'no older than X' to ensure the price is recent enough; fail the transaction if too old.
• Use confidence correctly: set a maximum threshold for confidence/price or use price ± k*confidence for liquidation/trigger to avoid oracle manipulation during high volatility.
• Handling feed status: ignore when status != trading (e.g., Halted/Auction).
• Automated updates: for use cases requiring continuous updates, use your Scheduler or job service to push VAAs regularly.
• Multi-source backup: even if it is first-party, you should still have a fallback (e.g., secondary feed or position freeze rules) to increase liveness.
⸻
Conclusion
Pyth shows a first-party + pull oracle approach: low latency, demand-based pricing, transparent confidence interval, along with a broad multi-chain infrastructure. In return, dApps need to proactively pull prices and manage risks correctly (staleness, status, confidence). With Benchmarks, Entropy, and Express Relay, Pyth is expanding from 'real-time pricing' into a comprehensive data/utility layer for on-chain finance.
@Pyth Network hashtag #PythRoadmap and $PYTH
