Alchemy RPC Pricing: A Guide to Understanding Costs

How Alchemy RPC Pricing Works

Alchemy uses a compute unit (CU) model to price its RPC services. Every request to an Alchemy endpoint consumes a certain number of CUs, and your monthly bill is largely determined by the total CUs your applications consume. The CU cost per request varies by method and network; for example, a simple eth_blockNumber call costs fewer CUs than a complex trace or debug call.

Alchemy offers multiple plan tiers, including a free tier for developers and paid tiers for production workloads. Each tier includes a monthly CU allowance, and additional usage is billed at a per-CU rate that may decrease at higher volumes. Exact allowances and rates are subject to change, so always refer to Alchemy's official pricing page for the most current information.

• Pricing is primarily based on compute units (CUs) consumed.
• Different RPC methods have different CU costs.
• CU costs can also vary by blockchain network.
• Plans include a monthly CU allowance; overages are billed separately.
• Free tier available for development and testing.

Understanding Compute Units (CUs)

Compute units are a normalized measure of the resources required to process an RPC request. Alchemy assigns CU values to each method based on factors like computational complexity, database lookups, and response size. For instance, reading a block header is relatively cheap, while executing a trace or querying logs over a large range can be more expensive.

Because CU costs are method-specific, the composition of your API traffic directly impacts your bill. Applications that rely heavily on expensive methods (such as debug_traceTransaction or eth_getLogs with wide ranges) will consume CUs faster than those making simple balance queries. Alchemy publishes a CU cost table for each supported network, which you can use to estimate your usage.

• CUs reflect the relative cost of each RPC method.
• Methods like eth_call and eth_getBalance have lower CU costs.
• Methods like debug_traceTransaction and eth_getLogs can have higher CU costs.
• CU costs may differ between networks (e.g., Ethereum vs. Polygon).
• Alchemy provides a CU cost reference for each network.

Plan Tiers and What They Include

Alchemy's pricing structure includes several tiers designed for different stages of development. The free tier typically provides a limited monthly CU allowance and basic support, suitable for prototyping and small projects. Paid tiers increase the CU allowance, offer higher rate limits, and may include enhanced support and features like dedicated infrastructure or advanced analytics.

Each tier has its own limits on requests per second (RPS) and other parameters. Upgrading a plan not only increases your CU allowance but also raises throughput limits, which can be important for production applications. Alchemy occasionally adjusts plan features and pricing, so check the official site for the latest details.

• Free tier: limited CUs, basic support, suitable for testing.
• Paid tiers: higher CU allowances and increased rate limits.
• Enterprise options may offer custom pricing and dedicated support.
• Plan features and limits are subject to change.
• Always verify current plan details on Alchemy's website.

Factors That Affect Your Alchemy RPC Bill

Several factors influence your monthly Alchemy bill beyond the raw number of requests. The types of methods you call, the networks you use, and your traffic patterns all play a role. For example, a dApp that frequently queries event logs over large block ranges will consume more CUs than one that primarily fetches account balances.

Additionally, using Alchemy's enhanced APIs (such as NFT or token APIs) may have different CU costs than standard JSON-RPC methods. It's important to understand the CU cost of each endpoint you use. Also, while Alchemy does not charge for bandwidth or data transfer in most plans, excessive usage beyond your plan's limits can lead to overage charges or throttling.

• Method mix: expensive methods increase CU consumption.
• Network choice: CU costs can vary by chain.
• Traffic volume: more requests mean more CUs.
• Enhanced APIs may have distinct CU costs.
• Overage fees apply when you exceed your plan's CU allowance.

Estimating Your Monthly Costs

To estimate your Alchemy RPC costs, start by identifying the RPC methods your application uses and their CU costs. Alchemy's documentation provides CU values for each method on each supported network. Multiply the number of calls per method by its CU cost to get the total CUs per period, then scale to a monthly estimate.

Next, compare your estimated monthly CU usage against the allowances of Alchemy's plans. If your usage exceeds the free tier, you can calculate the overage by multiplying the excess CUs by the per-CU rate for your chosen plan. Keep in mind that rates and allowances may change, so use current published figures and consider building in a buffer for traffic spikes.

• List all RPC methods your app calls.
• Find the CU cost for each method on Alchemy's site.
• Multiply call volume by CU cost to get total CUs.
• Compare total CUs to plan allowances.
• Calculate overage costs using current per-CU rates.

Tips to Optimize Alchemy RPC Costs

Optimizing your RPC usage can reduce your Alchemy bill. One effective strategy is to cache responses where appropriate, especially for data that doesn't change frequently, such as block data or static contract states. Another is to batch requests using JSON-RPC batch calls, which can reduce the number of individual requests and sometimes lower CU consumption.

You can also monitor your usage through Alchemy's dashboard, which provides insights into CU consumption by method and network. Setting up alerts for usage thresholds can help you avoid unexpected overages. Finally, review your method usage periodically to identify opportunities to replace expensive calls with cheaper alternatives when possible.

• Cache immutable or slow-changing data.
• Use JSON-RPC batching to combine multiple calls.
• Monitor CU usage via Alchemy's dashboard.
• Set usage alerts to avoid overages.
• Review and optimize expensive method calls.

Alchemy RPC URLs and Endpoints

When you sign up for Alchemy, you receive unique RPC URLs for each network and application. These URLs include your API key and are used to send requests. For example, an Ethereum mainnet endpoint might look like: https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY. Similar patterns apply to other networks like Polygon, Solana, and testnets.

It's important to keep your API keys secure and not expose them in client-side code. Alchemy provides separate URLs for different networks, so you can use the appropriate endpoint for each chain. The exact URL format may vary, so refer to your Alchemy dashboard for the correct endpoints.

• Endpoints are unique per app and network.
• URLs include your API key; keep them secret.
• Use the correct network-specific URL.
• Example format: https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY
• Find your endpoints in the Alchemy dashboard.

https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY
https://polygon-mainnet.g.alchemy.com/v2/YOUR_API_KEY
https://solana-mainnet.g.alchemy.com/v2/YOUR_API_KEY

Frequently Asked Questions

Q: Does Alchemy charge for failed requests? A: Generally, requests that result in an error may still consume CUs, depending on the error type. Check Alchemy's documentation for details.

Q: Can I set a spending limit? A: Alchemy may offer usage alerts and spending controls on certain plans. Refer to your plan details or contact support.

Q: Is there a minimum commitment? A: Most self-serve plans are month-to-month, but enterprise plans may have custom terms.