tenderly background
tenderly diamond

Node RPC

A high-performance node infrastructure designed to scale with your dapp wherever your users are.
Sign upContact sales
tenderly background

Single Node RPC to run and scale multichain dapps

Run and scale high-performance dapps on the only customizable node infrastructure for all major EVM chains, L2s, and rollups.
tenderly benefits

Infinitely scalable

Support high traffic volumes and usage spikes in your dapp, with soft rate limits and SLAs ensuring uninterrupted service globally.

tenderly benefits

Fully customizable

Build on top of a fully customizable Node RPC to set unique dapp logic and maintain optimal system performance.

tenderly benefits

Natively multichain

Expand to any major EVM chain from a single node – just swap the RPC and get your entire stack natively supported across chains.

up to 99.99% uptime SLA
as low as 0.01% error rate
on over 60+ networks
<100ms median latency
100% accurate gas estimates
<50ms avg. sim. exec. time
tenderly background

Developer-friendly node infrastructure

Extend your node RPC to create advanced dapp capabilities and a great user experience without additional infrastructure overhead.
Transaction simulations

Transaction simulations

Create a risk-free experience for your dapp users with built-in simulation infrastructure. Expose Tenderly simulations in your dapp to protect users’ assets, prevent transaction failures, and eliminate security risks.

Single simulations

Simulate single transactions to preview their exact outcomes before signing.

Learn more

Bundled simulations

Execute entire simulation bundles to test complex, interconnected transactions.

Learn more

Simulation mode

Run your entire dapp in simulation mode to enable gasless onboarding.

Learn more
Custom RPC endpoints & APIs

Custom RPC endpoints & APIs

Write and deploy custom code within our Node RPC to build unique dapp logic unlimited by general-purpose APIs. Replace fragile and constrained custom backends with serverless logic built specifically for your dapp.

Node Extensions

Create unique RPC endpoints to customize how your dapp interacts with the blockchain and ensure its scalability.

Learn more

Web3 Actions

Deploy a low-maintenance, automated serverless backend to respond to on-chain events and optimize performance.

Learn more
Automated monitoring

Automated monitoring

Monitor the usage and performance of your dapp in real time to catch issues as soon as they happen. Receive alerts for on-chain events and respond with custom code for instant damage control and optimal dapp performance.

Learn more

Real-time alerts

Track on-chain events in real time, including (un)successful transactions, balance changes, and contract interactions.

Team notifications

Receive alert notifications directly to your team channels such as email, Slack, Telegram, or PagerDuty.

Instant response

Connect with Web3 Actions or webhooks to respond to on-chain events automatically as soon as specified alerts are triggered. 

Integrate once, scale without limitations

Get all the standard capabilities to scale and expand your dapp across chains with a single Node RPC.
tenderly features

Multi-region support

Direct traffic to the most appropriate location with a smart routing system.

tenderly features

Unrivalled stability

Get guaranteed uptime globally and keep your system operational at all times.

tenderly features

High speed, low latency

Integrate the fastest Node RPC for the U.S. and Europe as per public benchmarks.

tenderly features

Complete accuracy

Deliver 100% accurate gas estimates to prevent out-of-gas errors.

tenderly features

Full archive data

Fetch complete archive data and perform read-heavy workloads at speed.

tenderly background

Pro dapps run on Tenderly Node RPC

The Tenderly RPC is one of crypto's best kept secrets. We've been using them for their performance and battle-tested reliability when other providers we used constantly had uptime issues.

Andrew Huang

Founder of Conduit

There's not a lot of competition on the node-as-a-service market, not at the same level. Unlike other node providers who treat the EVM as a black box, the guys from Tenderly know exactly what's going on inside the EVM and they know how to use it for simulations. It's a different level of understanding of the problem.

@poolpitako

Software Engineer, Yearn Finance

Case study

With Tenderly Node RPC as our node solution, we don’t have to worry about multi-chain setup and maintenance. Also, connecting our Tenderly Web3 Actions to the Tenderly Node resulted in x15 speed improvement, making our automation blazing fast.

0xGorillaDev.eth

CTO of Wonderland

Tenderly’s development tools and observability stack have become an essential part of our flow these past few years. And now with the fast and reliable Node RPC, Tenderly really makes all aspects of our development process as easy as possible.

Samyak Jain

Co-Founder and CTO at Instadapp

Integrate and scale within seconds

Add Node RPC to your development frameworks, client libraries, or dapp UI libraries with ready-made code snippets. Start using the best-performing node infrastructure across your projects within seconds.
  • Hardhat
  • Viem
  • Ethers
  • Wagmi
123456789101112131415161718192021
// Integration Instructions: https://docs.tenderly.co/node/integrations-smart-contract-frameworks/hardhat
import { HardhatUserConfig, task, types } from 'hardhat/config';
import '@nomicfoundation/hardhat-toolbox';
import * as tenderly from '@tenderly/hardhat-tenderly';
import * as dotenv from 'dotenv';

dotenv.configure();
tenderly.setup({ automaticVerifications: true });

const config: HardhatUserConfig = {
  solidity: '0.8.19',
  defaultNetwork: 'tenderly',
  networks: {
    tenderly: {
      url: 'https://optimism.gateway.tenderly.co/****',
      chainId: 10,
    },
  },
  tenderly: { username: '*****', project: 'project' },
  };
123456789101112
// Integration Instructions: https://docs.tenderly.co/node/integrations-chain-interaction/viem
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = createPublicClient({
  chain: mainnet,
  transport: http(
    "https://mainnet.gateway.tenderly.co/$TENDERLY_NODE_ACCESS_KEY"
  ),
});

console.log("Block Number", await client.getBlockNumber());
123456789101112131415
// Integration Instructions: https://docs.tenderly.co/node/integrations-chain-interaction/ethers
import { ethers } from "ethers";

const RPC_URL = "https://mainnet.gateway.tenderly.co/$TENDERLY_NODE_ACCESS_KEY"

async function executeMethod() {
  // Initialize an ethers provider instance
  const provider = new ethers.JsonRpcProvider(RPC_URL);

  const blockNumber = await provider.getBlockNumber();

  console.log(blockNumber);
}

await executeMethod();
1234567891011121314151617181920
// Integration Instructions: https://docs.tenderly.co/node/integrations-dapp-ui/wagmi
import { createConfig, http } from 'wagmi';
import { mainnet } from 'wagmi/chains';
import { injected, metaMask, safe, walletConnect } from 'wagmi/connectors';

const projectId = "WALLETCONNECT_PROJECT_ID";
const rpcUrl = "https://mainnet.gateway.tenderly.co/$TENDERLY_NODE_ACCESS_KEY";

export const config = createConfig({
  chains: [mainnet],
  connectors: [
    injected(),
    walletConnect({ projectId }),
    metaMask(),
    safe(),
  ],
  transports: {
    [mainnet.id]: rpcUrl,
  },
})

A gateway into the full-stack infrastructure

As the only node with integrated development environments and exploration tools, Node RPC gives you access to the entire Tenderly full-stack infrastructure.
Virtual TestNets
Developer Explorer
tenderly background

Integrate the only Node RPC you’ll need to run and scale killer dapps

Sign upContact sales