• Pricing
  • Enterprise
  • Customers
  • Blog

Simplifying Web3 infrastructure costs

Web3 relies on RPC nodes, which are the backbone of the system. But, using it is complex, even for experienced developers. More specifically, there are nuances in the node or client implementation. Different implementations may have uniquely different methods.

For example, debug_traceTransaction requires an archive node because the method retrieves a historical state to be able to replay previous transactions.

Moreover, new methods are constantly being introduced and existing implementations are being updated. For instance, failing to update the client implementation can lead to the risk of users ending up on the hard-forked chain. There is an ever-changing list of nuances and these dynamic variables make it challenging for developers to stay on top of changes. 

The unpredictability of Web3 node pricing units

To make matters worse, providers rely on unclear pricing strategies or utilize different units to describe the price of one API call. Some providers employ terms like “Compute Units” while others use “API Credits”. The main difference lies in the calculation. A single method request does not equal one API call. Instead, the number of compute units and credits deducted are determined by the resources consumed on the backend. The pricing model creates challenges for engineering teams in predicting costs and budgeting, causing financial uncertainty, and making it difficult to anticipate the size of the next bill.

Sometimes it is 8 credits; other times it can be 32 credits. It depends on the type of method and whether the request is for the most recent state or a historical state.

Here’s a quick comparison for example:

With Chainstack, every API call is always billed as 1 request

Things get even more complicated for non-Web3 natives. For one, they may struggle to figure out the function of each request. On top of that, they must scan through an exhaustive list of methods to match each request with its associated pricing. Even Web3 natives find this complicated, so needless to say, many do not delve into this level of granularity.

This makes predicting infrastructure costs difficult

Most developers may not know which requests or methods are required at the start and only discover what is necessary later. When a developer makes hundreds of millions of eth_getLogs requests, it can become overwhelming to realize the cost after the bills have accumulated.

For example, the chart below indicates the cost of making 100 million requests for each method.

See for yourself

Many end up spending more than intended when they are not aware of the costs associated with each method.

Budgeting is simple when one API call is always 1 request

With Chainstack, every API call to an RPC node is always billed as 1 request irrespective of the type of request or the required computation resources. This even applies to methods which call historical states.

This is what it means for the top 10 methods compared to other vendors.

Here is the comparison of the pricing for 30 million API calls for each of the top 10 methods for retrieving both the latest and historical state.

As can be seen, Chainstack is 86% more affordable compared to the other providers.

Hundreds of projects have migrated to Chainstack

One Chainstack request equals one API call, whether it’s a full or archive request. There are also no rate limits or throttling. This has led to hundreds of businesses and projects migrating to Chainstack from other vendors, citing cost transparency and unbeatable pricing as key reasons. Chainstack’s competitive and transparent pricing strategy is highly appealing to those considering a switch.

Doubtful? Here are actual workloads from clients who quickly switched to Chainstack after noticing the cost difference.

To compare vendors, we:

  1. Obtained official documentation of the number of compute units or API credits for each request.
  2. Extracted workloads from multiple migrated projects to Chainstack.
  3. Averaged the load profile across the same verticals.
  4. Adjusted for the optimal plan based on the number of requests.
  5. Gathered pricing information from each vendor’s page which includes prices for additional requests.
  6. Conducted comprehensive research and data collection from prospects and clients for non-public data.

Here is the average workload of top DEX aggregators using Chainstack.

And here is the average workload of top data providers using Chainstack.

Transparent pricing for all

In the Web3 industry, affordable infrastructure is crucial. Chainstack has developed a transparent pricing comparison tool, enabling developers and business executives to input requests across the top 10 methods or select between archive and full requests.

This tool helps projects and developers predict costs accurately and demonstrates our dedication to providing transparent and unbeatable pricing in the industry.

Final words

Cost transparency and unbeatable pricing are vital for Web3 development. Especially when funds become scarce during market turbulence. Projects and organizations need to budget and allocate resources more efficiently to build a financial buffer.

Aligning with the core principle of transparency, using a one-to-one API request approach simplifies onboarding and helps developers predict workload costs. This approach also avoids budgeting issues that may arise from needing to learn each method’s function when new developers join a project.

Power-boost your project on Chainstack

Have you already explored what you can achieve with Chainstack? Get started for free today.