Deeper application insights at lower costs

Build what you want, how you want, accessing the most value at fair, transparent prices. 

That’s why, after listening to your feedback, we’ve reduced the Compute Unit (CU) cost of four critical debug\_trace methods, giving you a more cost-effective solution for gathering comprehensive transaction execution details. 

debug\_trace methods are important for debugging, troubleshooting, and understanding why a contract behaved in a certain way. 

By re-architecting back end infrastructure, Alchemy has been able to pass up to 3x efficiency savings to you for four key debug\_trace methods:

• debug_traceBlockByHash
• debug_traceBlockByNumber
• debug_traceTransaction
• debug_traceCall

In practice, the reduction in CUs means you can access massive value and important insights at significantly reduced cost. 

Ready? Get started with debug\_trace methods today.

Remind me, what’s a compute unit (cu)?

Compute Units (CUs) measure total computational resources apps use when making requests on Alchemy, taking into account the fact that some queries are lightweight and fast to run (e.g., eth\_blockNumber) while others are more intense (e.g., eth\_getLogs). 

To that end, each method is assigned a quantity of CUs. You are charged based on the resources your application actually uses, rather than a flat fee per request. In this sense, CUs work like gas on mainnet, where the fee is correlated with a transaction’s execution. 

More to come on how to think about CUs within the broader marketplace. 

Digging into debug_trace

The substantial decrease in CUs for debug\_trace makes all of these calls considerably more affordable to use, enabling you to explore transaction execution at a granular level. 

Why does this level of detail matter?

It’s simple: The downside of contract execution is that it is very hard to tell what a transaction actually did.  

Existing methods to get transaction receipts, like eth\_getTransactionReceipt, while useful, lack granularity at the transaction execution level. 

When you’re trying to iron out a bug, this means that while some information can be gleaned, much more data is missing.

By contrast, debug\_trace methods capture a breakdown of what happens during a transaction's execution, a critical unlock for builders. These methods capture the intricate details of smart contract interactions, such as:

• The sequence of calls made between contracts
• The data passed and modified during those calls
• The gas usage at each step
• The success or failure status of individual actions

At this level of granularity, you can troubleshoot, look for efficiencies, and better understand your app. 

Who will benefit from this cost reduction?

You! 😁

More affordable debug_trace methods are super important across all Web3 verticals:

• Wallet builders: Get deeper insights into transaction processing and user interactions within your wallet.
• Analytics platforms: Detailed transaction data for more accurate and valuable insights into users.
• Marketplaces: Get a better sense of transaction flow to enhance security, help you track activity, and lead to optimized platform operations.
• Any app developer: Whatever you’re building, debug\_trace methods provide the best insights to build a killer, unbuggy app.

So what are you waiting for? 

Thousands of developers and teams are already building with Alchemy. In fact, if you’ve used any web3 app, you’ve probably used Alchemy. 

What to learn more? Dive into the docs today.

Frequently asked questions

What are debug_trace methods used for?

debug_trace methods provide detailed breakdowns of transaction execution, including the sequence of calls between contracts, data modifications, gas usage at each step, and success or failure status of individual actions. This granularity helps developers debug issues, optimize efficiency, and understand smart contract behavior beyond basic transaction receipts.

Which debug_trace methods are now 3x cheaper?

We reduced Compute Unit costs by up to 3x for four key methods: debug_traceBlockByHash, debug_traceBlockByNumber, debug_traceTransaction, and debug_traceCall.

What is a Compute Unit (CU)?

Compute Units measure the total computational resources apps use when making requests on our platform. You are charged based on the resources your application uses rather than a flat fee per request, similar to how gas works on mainnet.

Why use debug_trace instead of eth_getTransactionReceipt?

While eth_getTransactionReceipt is useful, it lacks granularity at the transaction execution level. debug_trace methods capture intricate details of smart contract interactions that are critical for troubleshooting and understanding what a transaction did.

Who benefits from cheaper debug_trace methods?

Wallet builders gain deeper insights into user interactions, analytics platforms access detailed transaction data, marketplaces can enhance security and track activity, and any app developer can troubleshoot and optimize more effectively.

How did we reduce debug_trace costs?

We re-architected backend infrastructure to achieve up to 3x efficiency savings, which are passed directly to developers through reduced Compute Unit costs.

Where can I learn more about using debug_trace methods?

You can dive into our documentation to get started with debug_trace methods, including implementation guides and usage examples.