Alchemy Ethereum Pricing: Plans, Tiers, and Cost Examples (2026)

Pricing overview

Alchemy Ethereum's pricing structure centers on a 'compute unit' (CU) model, which quantifies the computational resources consumed by various API requests. Different API calls, such as eth_call or eth_getBlockByNumber, are assigned varying CU costs reflecting their complexity and resource intensity. This approach allows developers to understand and predict costs based on their application's specific API usage patterns rather than simple request counts. Alchemy provides a detailed breakdown of compute unit costs for individual API methods within its documentation.

The service operates on a tiered subscription model, offering a free tier and several paid plans designed to accommodate varying levels of usage and feature requirements. Each plan includes a specific allocation of compute units per month, with additional usage typically billed as overage at a per-CU rate. Beyond compute units, higher-tier plans often include advanced features such as dedicated nodes, increased API request rates, enhanced debugging tools, and priority support. The pricing also factors in access to specialized APIs like the NFT API and Enhanced APIs, which offer optimized querying and data access for specific Web3 use cases.

Developers considering Alchemy Ethereum for their projects need to evaluate their anticipated API call volume and the complexity of those calls to select an appropriate plan. Tools for monitoring CU consumption are integrated into the Alchemy dashboard, enabling users to track their usage and manage costs effectively. This transparency aims to assist developers in optimizing their blockchain interactions and infrastructure spending.

Plans and tiers

Alchemy Ethereum offers multiple plans, starting with a free tier and scaling up to enterprise-level solutions. Each tier is designed to meet the needs of different user segments, from individual developers and startups to large-scale enterprises requiring robust infrastructure and support.

Specific details regarding plan features, exact CU costs for various API methods, and overage rates are subject to change and are maintained on the official Alchemy pricing page. The compute unit model allows for granular control over costs, as developers can optimize their code to reduce expensive API calls.

Free tier and limits

Alchemy's free tier, known as the 'Growth' plan, is designed to provide developers with sufficient resources to build and test Web3 applications without an upfront financial commitment. This tier includes a generous allocation of 50 million compute units (CUs) per month. For many development and small-scale deployment scenarios, 50 million CUs can support a substantial number of API calls, allowing for testing smart contracts, querying blockchain data, and developing user interfaces.

Key limits and features of the Growth free tier:

• Compute Units: 50 million CUs per month. If usage exceeds this limit, API requests may be throttled or blocked until the next billing cycle unless the user upgrades to a paid plan.
• Request Per Second (RPS) Limit: A rate limit of 3,000 requests per second is imposed to ensure fair usage of shared infrastructure.
• Infrastructure: Users on the Growth plan access shared node infrastructure.
• Included APIs: Access to Alchemy's core Supernode functionality and Enhanced APIs, which provide optimized data queries and abstraction layers over raw blockchain data.
• Support: Standard community and documentation-based support channels are available.

The Growth plan is suitable for individual developers, hobbyists, and early-stage projects that are still in the development or testing phases. It allows users to leverage Alchemy's developer tools and infrastructure to build functional dApps before needing to commit to a paid subscription. For detailed information on specific CU costs per API call, refer to the Alchemy Compute Unit Reference documentation.

Real-world cost examples

Understanding Alchemy's compute unit (CU) model through practical examples can help developers estimate potential costs. The CU cost for an API request varies based on its complexity. For instance, a simple eth_blockNumber call might cost 10 CUs, while a more complex eth_getBlockByNumber with transaction details could cost 100 CUs or more, and a historical query like eth_getLogs over a large block range could be significantly higher.

Consider the following scenarios:

1. Small dApp (Free Tier): A dApp that queries the current block number every 10 seconds and fetches transaction details for a user's wallet once per minute. Assuming eth_blockNumber costs 10 CUs and eth_getBalance costs 20 CUs:

   • Block number queries: (6 queries/minute * 60 minutes/hour * 24 hours/day * 30 days/month) * 10 CUs = 2,592,000 CUs
   • Balance queries: (1 query/minute * 60 minutes/hour * 24 hours/day * 30 days/month) * 20 CUs = 864,000 CUs
   • Total: Approximately 3.456 million CUs per month. This usage comfortably fits within the 50 million CU free tier.

2. NFT Marketplace (Starter Plan): An NFT marketplace with moderate traffic, performing frequent metadata lookups and transaction simulations. Suppose it averages 100,000 alchemy_getAssetTransfers (approx. 500 CUs each) and 50,000 eth_call (approx. 200 CUs each) per day.

   • Asset transfers: (100,000 calls/day * 30 days/month) * 500 CUs = 1.5 billion CUs
   • eth_call: (50,000 calls/day * 30 days/month) * 200 CUs = 300 million CUs
   • Total: Approximately 1.8 billion CUs per month.

   This significantly exceeds the Starter plan's 100 million CU allocation. The usage would incur overage charges. At an overage rate of $0.000007 per CU, the cost for 1.7 billion CUs above the allocated amount would be 1,700,000,000 * $0.000007 = $11,900. Plus the base $49 for the Starter plan, the total would be approximately $11,949.

   This scenario illustrates that while the Starter plan provides a base, high-volume applications quickly move into significant overage costs. Such a project would likely be better suited for the Growth+ or Enterprise plan, which offer much higher CU allocations at a lower effective per-CU rate.

3. DeFi Protocol (Developer Plan): A DeFi protocol that relies on frequent historical data queries and transaction analysis. It executes 5 million eth_getLogs requests (average 500 CUs each) and 1 million debug_traceTransaction requests (average 1,000 CUs each) per month.

   • eth_getLogs: 5,000,000 calls * 500 CUs = 2.5 billion CUs
   • debug_traceTransaction: 1,000,000 calls * 1,000 CUs = 1 billion CUs
   • Total: Approximately 3.5 billion CUs per month.

   The Developer plan provides 500 million CUs. This usage would require an upgrade to Growth+ (5 billion CUs) or an Enterprise plan to manage costs effectively and avoid substantial overages.

These examples highlight the importance of monitoring CU usage and selecting a plan that aligns with the application's expected API consumption. Developers can use Alchemy's dashboard analytics to track their CU usage and adjust their plan as needed to optimize costs.

How the pricing compares

Alchemy Ethereum operates within a competitive landscape of blockchain infrastructure providers, each with distinct pricing models. Key competitors include Infura and QuickNode, both of which also offer free tiers and tiered subscription models for accessing Ethereum and other blockchain networks.

• Infura: Infura typically uses a request-based pricing model, where costs are determined by the number of API requests rather than a compute unit system. Infura's free tier, known as the 'Core' plan, provides 100,000 requests per day (approximately 3 million requests per month) for standard API calls and limited access to archive data. Paid plans scale up based on request volume. This model can be simpler to predict for applications with consistent, low-complexity requests but may become less cost-effective for applications making many complex, resource-intensive calls, which Alchemy's CU model aims to reflect more accurately. Infura's pricing details can be found on their official pricing page.

• QuickNode: QuickNode also employs a request-based model, often measured in 'API Credits' or 'Requests.' Their free tier typically includes a certain number of API credits per month, with paid plans offering higher credit allocations and advanced features like dedicated nodes and analytics. QuickNode's pricing often emphasizes high throughput and low latency, with tiers designed for various scales of dApp deployment. Similar to Infura, projects with highly variable API call complexity might find Alchemy's CU model offers a more granular cost reflection, while those with predictable, high-volume simple requests might find QuickNode or Infura's request-based models straightforward. QuickNode publishes its pricing on its pricing page.

The choice between Alchemy's compute unit model and the request-based models of competitors often depends on the specific workload and complexity of the dApp. For applications that frequently make complex or resource-intensive queries, Alchemy's CU model might provide a more transparent and potentially more cost-effective solution by directly correlating cost to resource consumption. Conversely, dApps with a high volume of simple, low-cost API calls might find a request-based model easier to budget for. Additionally, the availability and cost of advanced features like dedicated nodes, archive data access, and specialized APIs (e.g., NFT APIs) vary between providers and should be factored into a comprehensive cost comparison. As the Web3 ecosystem evolves, pricing structures across providers may continue to adapt to developer needs and market dynamics, as noted by industry analyses of blockchain API services.