# Tenderly MCP

> Tenderly (Ethereum Dev Platform) MCP connects your AI agent directly to Ethereum development tools. Simulate transactions and full transaction bundles without spending gas or touching live funds. You can build private virtual test networks, monitor specific on-chain events in real time, and validate complex contract logic before deployment.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** smart-contracts, ethereum, transaction-simulation, web3-debugging, testnet, blockchain-monitoring

## Description

Need to debug smart contracts? This MCP lets you simulate any Ethereum action—from a single token transfer to a massive, multi-step DeFi protocol interaction—without spending gas or committing actual assets. Your agent handles the heavy lifting, allowing you to test code logic in an environment that feels exactly like mainnet.

Want to test your dApp against live production conditions? You can spin up private virtual networks that mimic Mainnet at any specific block height. If you're working with complicated contract interactions, you can also simulate entire bundles of transactions together just to see how they play out. Plus, set up advanced alerts for specific method calls or state changes, keeping you instantly informed about critical blockchain activity. It’s a powerful debugging suite that connects easily through Vinkius, so connecting your favorite AI client is straightforward.

## Tools

### create_alert
Set up real-time monitoring to notify you whenever a defined blockchain event occurs on Tenderly.

### create_virtual_testnet
Instantly spin up a private, isolated copy of the Ethereum network for controlled development testing.

### simulate_bundle
Run and evaluate multiple transactions as a single group to test complex workflow dependencies.

### simulate_transaction
Perform a dry run of any single transaction, showing you the resulting state changes without spending gas.

## Prompt Examples

**Prompt:** 
```
Simulate a transaction on Ethereum Mainnet from 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 to 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D with data 0x095ea7b3...
```

**Response:** 
```
I've simulated the transaction. The simulation was successful, consuming 45,000 gas. It would result in an ERC20 Approval event for the Uniswap V2 Router. Would you like to see the full state changes?
```

**Prompt:** 
```
Create a Virtual TestNet named 'Staging-Fork' forked from Mainnet at the latest block.
```

**Response:** 
```
Virtual TestNet 'Staging-Fork' has been created successfully. You can now access it via the generated RPC URL. The Chain ID is set to your specified virtual ID.
```

**Prompt:** 
```
Set up an alert to notify me whenever the 'transfer' method is called on contract 0x123...
```

**Response:** 
```
I've created the alert for contract 0x123... monitoring the 'transfer' method. You will receive notifications based on your Tenderly project settings whenever this event is detected on-chain.
```

## Capabilities

### Test transaction outcomes
Simulate single transactions or complex groupings of actions without spending any real gas.

### Build private test environments
Create and manage virtual replicas of the main Ethereum network for isolated testing.

### Monitor blockchain activity
Set up alerts to get real-time notifications when specific contract events happen on the chain.

### Validate multi-step workflows
Run sequences of transactions together to see how complex protocols interact.

## Use Cases

### Debugging an approval flow
A smart contract engineer needs to verify if an ERC20 token will successfully approve funds for a new router address. They ask their agent to `simulate_transaction` on the specific addresses and data, instantly seeing the resulting Approval event without using real test tokens.

### Testing a new protocol version
A DeFi researcher is building out a concept that needs Mainnet conditions but shouldn't touch live funds. They instruct their agent to `create_virtual_testnet` forked from the current Mainnet block, giving them a safe space to test complex interactions.

### Monitoring for fraud
A Web3 DevOps team suspects a key contract is being misused. They ask their agent to `create_alert` specifically watching for unauthorized value transfers or state changes on that contract, getting immediate alerts 24/7.

### Validating multi-signature governance
A team needs to ensure a sequence of three different committee votes works correctly. They use `simulate_bundle` to run the entire flow in one go, ensuring that the transactions don't conflict and finalize successfully.

## Benefits

- Stop wasting time on basic testing. Use `simulate_transaction` to run dry simulations of any transfer or call, confirming contract behavior before you deploy anything.
- Need a clean slate for development? With `create_virtual_testnet`, your agent builds private mainnet replicas so you can test against custom configurations without affecting production data.
- Forget manually checking logs. Use `create_alert` to monitor specific method calls or state changes, getting instant notification the moment an event happens on-chain.
- Complex DeFi logic demands more than one step. Running a full sequence via `simulate_bundle` lets you test multi-protocol interactions as if they happened live.
- Your agent manages all this complexity across multiple tools, giving you full visibility into transaction lifecycles from a single prompt.

## How It Works

The bottom line is: you talk to your agent using natural language, and it handles all the complex blockchain setup and execution for you.

1. First, subscribe to this MCP and provide your specific Tenderly access credentials: the Access Key, Account Slug, and Project Slug.
2. Next, tell your AI client exactly what you need. Do you want to simulate a transfer? Should you set up an alert for a state change? Or maybe create a virtual test network?
3. The MCP executes the request on Tenderly and returns the results—whether that's a successful simulation report or confirmation that your private TestNet is ready.

## Frequently Asked Questions

**Can I use Tenderly (Ethereum Dev Platform) MCP to test transactions?**
Yes, you can simulate any single transaction or a group of them using `simulate_transaction` or `simulate_bundle`. This runs the test without spending actual gas.

**What is a Virtual TestNet in Tenderly (Ethereum Dev Platform) MCP?**
A Virtual TestNet lets you create a private, temporary copy of the Ethereum network. You can use this environment to test your dApp against production-like conditions safely.

**Does Tenderly (Ethereum Dev Platform) MCP require actual funds?**
No. The entire purpose of this MCP is simulation and monitoring, so you never risk spending real assets or gas fees while developing.

**How do I monitor live events with Tenderly (Ethereum Dev Platform) MCP?**
You use the `create_alert` tool. You specify exactly what event or state change you want to track, and your agent handles setting up the persistent monitoring.

**Is Tenderly (Ethereum Dev Platform) MCP compatible with all AI clients?**
Yes, because it's an open standard through Vinkius, any MCP-compatible client like Cursor or Claude can connect to and use its tools.