Push Oracles vs Pull Oracles: 2026

Proactive Data Delivery: Data is automatically pushed on-chain at predefined intervals or thresholds (e.g., Chainlink Data Feeds). This matters for DeFi protocols like Aave or Compound that require continuous, up-to-date price data for liquidations and interest rates.

• Lower On-Chain Latency: Updates are already on-chain when needed, enabling sub-second execution for critical functions.
• Simpler Smart Contract Logic: Contracts just read from a storage variable; no need to manage request lifecycle.

Inefficient for Infrequent Data: Paying for continuous updates (e.g., every block) is wasteful for data needed only occasionally, like a sports score or election result. This directly impacts operational costs on high-throughput chains.

• Higher Baseline Cost: Protocols bear the gas cost for all updates, regardless of usage.
• Less Flexible: Cannot request custom, one-off data points without a separate, dedicated feed.

Cost-Efficient & On-Demand: Data is fetched only when a user transaction requires it (e.g., API3 dAPIs, Pyth's Pull Oracle). This matters for NFT minting based on real-world events or insurance claims processing, where data requests are sporadic.

• User-Pays Model: The requester (end-user) bears the gas cost for the data fetch, aligning costs with usage.
• Unlimited Data Variety: Can access any verifiable data point via a single oracle design, enabling long-tail use cases.

Higher Per-Request Latency: The fetch-and-verify cycle adds 1-3+ seconds to the user's transaction. This is problematic for high-frequency trading (HFT) bots or instant settlement DEXs where every millisecond counts.

• Complex User Experience: Requires users to sign two transactions (request & fulfillment) or use meta-transactions, increasing UX friction.
• Front-Running Risk: The request phase can expose pending data needs to MEV searchers.

Key advantage: Data is pushed on-chain automatically by the oracle network when conditions are met (e.g., price deviation). This enables real-time, event-driven smart contracts.

• Use Case Fit: Ideal for liquidation engines (e.g., Aave, Compound) and limit orders that require sub-second execution.
• Example: Chainlink Automation pushes price updates to trigger a liquidation when collateral ratio falls below threshold.

Key advantage: Gas costs for data updates are borne by the oracle service or a designated payer, not the end-user. This provides budget certainty for dApp operators.

• Use Case Fit: Critical for subscription-based services and enterprise DeFi where operational expenses must be forecasted.
• Metric: Protocols like UMA's Optimistic Oracle use push mechanics where disputers pay gas, shielding end-users from volatility.

Key advantage: Data is fetched on-chain only when a user transaction requires it. This eliminates costs for unused updates and reduces overall network bloat.

• Use Case Fit: Perfect for low-frequency data checks, governance voting (e.g., Uniswap's TWAP), and batch processing.
• Example: Tellor's proof-of-work oracle provides data via a pull model, where the requester pays gas only for the specific query they need.

Key advantage: The data received is the absolute latest at the moment of the pull request. There is no risk of staleness between scheduled push updates.

• Use Case Fit: Essential for settlement of high-value OTC trades, arbitrage bots, and any application where the latest tick is mission-critical.
• Trade-off: This freshness comes at the cost of higher and less predictable gas fees for the end-user initiating the pull.

Key weakness: Data can become stale between push intervals. Overly aggressive push frequency to combat this leads to high, recurring gas costs and blockchain bloat.

• Impact: A push oracle with a 1-hour update cycle is unsuitable for a perpetual futures market requiring second-level precision.
• Mitigation: Protocols like Pyth Network use high-frequency push (400ms) but this is cost-prohibitive for many use cases.

Key weakness: Requires a user to initiate and pay for the on-chain transaction, adding friction and unpredictable costs. It also introduces latency for the initial data fetch.

• Impact: A poor fit for fully automated, gasless user experiences or keeper network triggers that cannot rely on user action.
• Example: A user might abandon a swap if they must first pay a $5 gas fee to pull a price oracle update.