In modern EVM development, engineers need more than a standard RPC endpoint. When a trace is required to analyze execution, or when a developer needs to inspect internal state transitions, a simple request is not enough. This is why NOWNodes now enables full Trace API and Debug API support across all major EVM networks — giving developers a complete interface to inspect, validate, analyze, and retrieve every internal operation within a transaction.
This update is especially important because many providers classify each trace method request as a high-cost CU operation, often pricing a single trace API request at 1 CU per call.
At NOWNodes, all APIs — including every trace method — follow the same pricing model, meaning you can use advanced RPC functionality without unpredictable billing spikes. A single subscription covers all requests, including heavy trace workloads.
Trace API vs Debug API: Specification Overview
| Feature | Trace API | Debug API |
|---|---|---|
| Goal | Analyze execution and reconstruct a trace of internal operations | Retrieve opcode-level debug information |
| Trace Method Types | trace_transaction, trace_block, trace_call, trace_callMany, trace_filter | debug_traceTransaction, debug_traceCall, debug_traceBlock |
| Usage | Transaction trace, request simulations, analyzing trace types and sampling | Step-by-step opcode reporting, runtime analysis |
| HTTP Interface | Standard HTTP RPC endpoint | Same HTTP interface |
| Enable / Disable | Enabled by default on NOWNodes | Enabled on supported networks |
| Trace Types | All major EVM trace types | Execution-level traces |
| Use Cases | Analyzer tools, enterprise observability, instrumentation | Debug, validate, optimize |
Understanding the Trace API: The Core Trace Method for EVM Analysis
The Trace API is the primary mechanism used by developers to reconstruct execution. A trace request allows a developer to retrieve internal calls, downstream interactions, input parameters, and side effects that occur within a transaction. Because the trace API operates at the execution level, it captures intermediate operations that standard logs exclude.
When a developer sends an HTTP request using trace_transaction or trace_block, the server generates a trace that corresponds to the actual EVM runtime. This process involves instrumentation, sampling, and analyzing every nested call. The tracer can define how much detail to include or exclude, and a trace can be customized with optional configuration attributes.
Use Cases for the Trace API
- analyzing DeFi protocols
- generating a full execution trace for audits
- performing asynchronous simulations with
trace_call - retrieving historical trace data with
trace_filter - building observability and reporting tools that rely on trace types
The trace API is extremely useful for enterprise platforms where execution transparency is a requirement.
Debug API: A Deeper Specification for Opcode-Level Reporting
While the trace API focuses on execution flow, the debug API focuses on opcode behavior. With debug_traceTransaction and debug_traceCall, a developer can analyze stack changes, memory modifications, propagator behavior, latency, and interpreter logic. The debug API uses a tracer component that can capture optional state attributes such as storage diffs.
Debug traces help define the exact mechanism that caused a revert, and they validate the logic of the smart contract implementation. A developer can also use the debug API to retrieve storage snapshots (debug_storageRangeAt) or report problematic block processing using debug_getBadBlocks.
Debug API is effectively the open-source EVM disassembler for RPC clients.
When to Use Trace API vs When to Use Debug API
Use the Trace API when you need:
- to analyze the execution path
- to generate a trace for audits
- to trace using
trace_callwithout writing state - to retrieve large sets of traces for analytics
- to understand trace types in complex DeFi operations
Use the Debug API when you need:
- opcode-level instrumentation
- to verify stack behavior
- to locate side effects leading to a revert
- to analyze intermediate states not visible in logs
- to ensure telemetry or observability coverage
Both APIs correspond to different depths of analysis. Developers often pair trace and debug methods to create a complete view of transaction behavior.
Why NOWNodes Is the Most Cost-Efficient Way to Use Trace API
Many RPC providers treat trace requests as “premium” operations. A single trace request can cost 1 CU per call, making large-scale analytics impractical.
NOWNodes removes this barrier by treating all RPC requests equally, including every trace method and debug call. This makes it possible to:
- run trace-heavy workloads
- build analytics pipelines
- perform bulk execution analysis
- run high-frequency simulations
—all without unpredictable billing.
In other words: you can generate thousands of trace requests per minute without paying 10–50× more, as is common with other API providers.
This benefit is especially relevant for platforms that process execution traces locally or use an algorithm to generate chart-ready observability data at scale.
Getting Started with the Trace API on NOWNodes
A developer only needs the HTTPS RPC endpoint and an API key (credential). The trace API request format follows the standard JSON-RPC specification. The default HTTP client configuration works without modification, and you can explicitly specify parameters such as tracer type, sampling configuration, or optional runtime flags.
Once enabled, the server responds with complete trace data, including nested operations, start and end time, and internal execution details.
The documentation includes code samples, Java examples, and instructions on how to create a new trace integration on your platform.
Conclusion
The trace API is an essential developer interface for analyzing EVM execution. Combined with the debug API, it forms a complete instrumentation layer for open source, enterprise, and analytics applications. With NOWNodes providing full support for every trace method — and doing so without additional CU-based pricing — developers finally have a scalable, cost-efficient, and specification-accurate RPC solution.
