Changelog

Greg

Ever wondered if your token is supported on Universal Bridge? You can check all routes for a given token using the routes page. Search by chain ID, token address, token symbol, or name for all origin and destination routes. You can access the site at thirdweb.com/routes.

0:00
/0:17
Greg

You can use the transactions array returned by a Universal Bridge prepared quote to easily execute a full route from origin to destination. This pattern is now even easier with transaction action fields included to denote what each transaction does. The most important of these actions is the approval type, which represents a pre-assembled approval transaction. The approval will account for the sender's existing set allowance and what token is needed for the next step.

A quote response might look something like this:

{
id: "0xf04cca9127820d71ab8fe588ed9532d14d61ee883bfe29870873258646d8a03e",
originAmount: "1003793",
destinationAmount: "1000000",
blockNumber: "133945469",
timestamp: 1743489718527,
estimatedExecutionTimeMs: 62000,
intent: {
originChainId: 10,
originTokenAddress: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
destinationChainId: 8453,
destinationTokenAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
buyAmountWei: "1000000",
sender: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
receiver: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
},
transactions: [
{
chainId: 10,
to: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
data: "0x...",
type: "eip1559",
id: "0x723a578f5f04178f410da8e2029c138d4cad76900a9d9e650603fc64e56e113b",
action: "approval",
}, {
to: "0x81d57DD01a15BC1C19563693902df621500D4d2A",
value: "0",
data: "0x...",
chainId: 10,
from: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
type: "eip1559",
action: "buy",
id: "0x3f0cb9f8a3e8649284d5c3f44648237f821c19de490fce9572509d79292867dc",
}
],
}

To execute this bridge with the TypeScript SDK, use sendAndConfirmTransaction to send each transaction, and wait for a successful Bridge.status response for each non-approval transaction:

import { Bridge, sendAndConfirmTransaction } from "thirdweb";
for (const tx of preparedBuy.transactions) {
const hash = await sendAndConfirmTransaction({
transaction: prepareTransaction(tx),
account, // Learn to generate a thirdweb account https://portal.thirdweb.com/connect/wallet/get-started
});
if (tx.action !== "approval") {
// Wait for Bridge.status to return "COMPLETED" status
}
}

It's that easy to implement bridging and swapping in your app. Want to get started? You can find the full API reference here.

Toomas Oosalu

Insight now supports webhooks so you can build pipelines and receive notifications when specific blockchain events or transactions occur!

What does this mean?

With the introduction of webhook support in Insight, you can now seamlessly integrate blockchain data into your applications or workflows. Webhooks allow you to automatically receive near real-time notifications whenever specific blockchain events or transactions occur, eliminating the need for constant polling of the blockchain.

What can I do with it?

  • Automate Workflows: Trigger actions in your applications or services when a specific blockchain event happens (e.g., a token transfer, contract interaction, or wallet activity).
  • Monitor Blockchain Events: Stay updated on relevant events without manually querying the blockchain.
  • Build Custom Pipelines: Use webhooks to feed blockchain data into analytics tools, databases, or other systems for further processing.
  • Filter Specific Data: Configure webhooks to only receive notifications for events or transactions that meet your specific criteria, such as a particular contract address or event type.

Can I receive decoded events and transactions?

Yes! Insight webhooks provide decoded data for events and transactions. This means you’ll receive human-readable payloads that include all relevant details, such as parameters and values associated with the event or transaction. This makes it easier to process and use the data directly in your applications without additional decoding steps.
To enable this, you have to define specific event signatures / function signatures and partial ABIs in the webhook filter configurations.

For more details on setting up and managing webhooks, visit the following resources:


📖 Learn more about Insight - it’s open source and ready to power your applications!

Yash Kumar
Samina Kabir

We’ve released the Agglayer Module, designed to enable secure and seamless cross-chain transfers of ERC-20 tokens using Agglayer, an interoperability protocol. Learn more about Agglayer.

Please note: This module is currently in beta while the Agglayer bridge is not live in implementation. This means deployments are limited to Sepolia and Cardona as it requires Ethereum as an L1 and zkEVM as L2.

🧩 What is it?

The Agglayer Module is a module contract that can be added to any ERC-20 modular contract built with thirdweb’s modular framework. It allows developers to bridge ERC-20 tokens across any EVM-compatible chain.

🌐 Why it matters

As the Ethereum ecosystem continues to grow with the introduction of more Layer 2 networks, fragmented liquidity and isolated user experiences have become major challenges. Without interoperability, assets are locked within specific chains, limiting usability and adoption.

The Agglayer Module helps address this by enabling interoperability at the contract level—allowing tokens to move freely across chains, reducing fragmentation, and improving the overall developer and user experience.

✅ Key Benefits

  • EVM-compatible – Works across all EVM chains
  • Modular and upgradeable – Can be installed or removed from any ERC-20 modular contract
  • Dashboard integration – Easily install through the thirdweb dashboard with no additional configuration
  • Cross-chain functionality – Mint tokens and send them to other chains seamlessly

⚠️ Requirements

  • The module currently only works with ERC-20 modular contracts
  • It must be installed on the contract in order to function

🛠 How to use it

  1. Use or deploy an ERC-20 modular contract
  2. Add the Agglayer Module through the thirdweb dashboard
  3. Mint and bridge tokens as needed

📚 View the full tutorial

As always, please don't hesitate to contact us for any questions or support.

Toomas Oosalu

Insight added support for querying a wallet's transactions (both inbound and outbound). Previously this had to be two separate queries, but can now be done by a single query.

Try it out in our playground

To fetch a wallet's transactions on Ethereum

const getWalletTransactions = async (walletAddress: string) => {
try {
const response = await fetch(
`https://1.insight.thirdweb.com/v1/wallets/${walletAddress}/transactions`,
{
headers: {
"x-client-id": <THIRDWEB_CLIENT_ID>,
},
},
);
const res = await response.json();
return res.data;
} catch (error) {
console.error("Error:", error);
}
};

📖 Learn more about Insight - it’s open source and ready to power your applications!

Greg

With v5.93.0 of the TypeScript SDK, we've added full beta functionality for thirdweb's new Universal Bridge. The bridge currently covers 50+ chains and over 30,000 routes.

  • Bridge.Buy - Specify an exact destination amount to receive
    • quote: Get estimates without a wallet connection
    • prepare: Get finalized quotes with transaction data
  • Bridge.Sell - Specify the exact origin amount to send
    • quote: Get estimates without a wallet connection
    • prepare: Get finalized quotes with transaction data

How to Send Transactions

When you call prepare, you might get multiple transactions back. You must send all transactions in order and sequentially for the full route to succeed. Before sending each transaction, call Bridge.status for the previous transaction until it returns COMPLETED. Do not simply wait for the transaction receipt, as this doesn't account for the destination chain transaction (if there is one).

The transactions returned do not include approvals. Send any necessary approvals before their corresponding transactions.

Route Discovery & Transaction Tracking

  • Bridge.routes - Advanced function to discover and filter available bridge routes
    • Filter by token address, chain ID, or both
    • Full pagination support with customizable limit and offset
  • Bridge.status - Comprehensive transaction status tracking
    • Clear status indicators: "COMPLETED", "PENDING", "FAILED", or "NOT_FOUND"
    • Detailed transaction reporting including origin and destination amounts and chains

Types

  • Standardized error handling with descriptive, formatted error messages
  • Four underlying types are exported for use with the bridging functions:
    • Route: Defines bridge routes between chains and tokens
    • Status: Represents bridge transaction status data
    • Quote: Contains detailed bridge transaction quote information
    • PreparedQuote: Extends Quote with complete transaction data

Implementation Examples

Bridge.Buy Usage Example

import { Bridge, toWei, NATIVE_TOKEN_ADDRESS } from "thirdweb";
// First, get a quote to see approximately how much you'll pay
const buyQuote = await Bridge.Buy.quote({
originChainId: 1, // Ethereum
originTokenAddress: NATIVE_TOKEN_ADDRESS,
destinationChainId: 10, // Optimism
destinationTokenAddress: NATIVE_TOKEN_ADDRESS,
buyAmountWei: toWei("0.01"), // I want to receive 0.01 ETH on Optimism
client: thirdwebClient,
});
console.log(
`To get ${buyQuote.destinationAmount} wei on destination chain, you need to pay ${buyQuote.originAmount} wei`,
);
// When ready to execute, prepare the transaction
const preparedBuy = await Bridge.Buy.prepare({
originChainId: 1,
originTokenAddress: NATIVE_TOKEN_ADDRESS,
destinationChainId: 10,
destinationTokenAddress: NATIVE_TOKEN_ADDRESS,
buyAmountWei: toWei("0.01"),
sender: "0x...", // Your wallet address
receiver: "0x...", // Recipient address (can be the same as sender)
client: thirdwebClient,
});
// The prepared quote contains the transactions you need to execute
console.log(
`Transactions to execute: ${preparedBuy.transactions.length}`,
);

Bridge.Sell Usage Example

import { Bridge, toWei } from "thirdweb";
// First, get a quote to see approximately how much you'll receive
const sellQuote = await Bridge.Sell.quote({
originChainId: 1, // Ethereum
originTokenAddress: NATIVE_TOKEN_ADDRESS,
destinationChainId: 10, // Optimism
destinationTokenAddress: NATIVE_TOKEN_ADDRESS,
sellAmountWei: toWei("0.01"), // I want to sell 0.01 ETH from Ethereum
client: thirdwebClient,
});
console.log(
`If you send ${sellQuote.originAmount} wei, you'll receive approximately ${sellQuote.destinationAmount} wei`,
);
// When ready to execute, prepare the transaction
const preparedSell = await Bridge.Sell.prepare({
originChainId: 1,
originTokenAddress: NATIVE_TOKEN_ADDRESS,
destinationChainId: 10,
destinationTokenAddress: NATIVE_TOKEN_ADDRESS,
sellAmountWei: toWei("0.01"),
sender: "0x...", // Your wallet address
receiver: "0x...", // Recipient address (can be the same as sender)
client: thirdwebClient,
});
// Execute the transactions in sequence
for (const tx of preparedSell.transactions) {
// Send the transaction using your wallet
// Wait for it to be mined
}

Route Discovery Example

import { Bridge, NATIVE_TOKEN_ADDRESS } from "thirdweb";
// Get all available routes
const allRoutes = await Bridge.routes({
client: thirdwebClient,
});
// Filter routes for a specific token or chain
const filteredRoutes = await Bridge.routes({
originChainId: 1, // From Ethereum
originTokenAddress: NATIVE_TOKEN_ADDRESS,
destinationChainId: 10, // To Optimism
client: thirdwebClient,
});
// Paginate through routes
const paginatedRoutes = await Bridge.routes({
limit: 10,
offset: 0,
client: thirdwebClient,
});

Transaction Status Monitoring Example

import { Bridge } from "thirdweb";
// Check the status of a bridge transaction
const bridgeStatus = await Bridge.status({
transactionHash:
"0xe199ef82a0b6215221536e18ec512813c1aa10b4f5ed0d4dfdfcd703578da56d",
chainId: 8453, // The chain ID where the transaction was initiated
client: thirdwebClient,
});
// The status will be one of: "COMPLETED", "PENDING", "FAILED", or "NOT_FOUND"
if (bridgeStatus.status === "completed") {
console.log(`
Bridge completed!
Sent: ${bridgeStatus.originAmount} wei on chain ${bridgeStatus.originChainId}
Received: ${bridgeStatus.destinationAmount} wei on chain ${bridgeStatus.destinationChainId}
`);
} else if (bridgeStatus.status === "pending") {
console.log("Bridge transaction is still pending...");
} else {
console.log("Bridge transaction failed");
}

Error Handling Implementation

try {
await Bridge.Buy.quote({
// ...params
});
} catch (error) {
// Errors will have the format: "ErrorCode | Error message details"
console.error(error.message); // e.g. "AmountTooHigh | The provided amount is too high for the requested route."
}

Module Integration

The Bridge module is accessible as a top-level export:

import { Bridge } from "thirdweb";

Use Bridge.Buy, Bridge.Sell, Bridge.routes, and Bridge.status to access the corresponding functionality.

Or, import the functions directly from the module:

import { Buy, Sell, routes, status } from "thirdweb/bridge";
Firekeeper

We've built Universal Bridge to allow your users to use any asset on any chain, and it's ready for you to try.

This integration simplifies onchain asset trading, and we've added extensions in .NET to integrate with any IThirdwebWallet nicely.

Core APIs

The design is akin to letting us know what your intent is.

  • Buy: "I want to buy x USDC on y Chain using z Token"
  • Sell: "I want to sell x USDC on y Chain for z Token"
  • Transfer: "Just transfer all my money to vitalik"

We will return the transactions needed to achieve whatever you desire.
You may then handle execution yourself or use our extensions.

Instantiation

using Thirdweb.Bridge;
// Create a ThirdwebBridge instance
var bridge = await ThirdwebBridge.Create(client);

Buy - Get a quote for buying a specific amount of tokens

var buyQuote = await bridge.Buy_Quote(
originChainId: 1,
originTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
destinationChainId: 324,
destinationTokenAddress: Constants.NATIVE_TOKEN_ADDRESS, // ETH on zkSync
buyAmountWei: BigInteger.Parse("0.1".ToWei())
);
Console.WriteLine($"Buy quote: {JsonConvert.SerializeObject(buyQuote, Formatting.Indented)}");

Buy - Get an executable set of transactions (alongside a quote) for buying a specific amount of tokens

var preparedBuy = await bridge.Buy_Prepare(
originChainId: 1,
originTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
destinationChainId: 324,
destinationTokenAddress: Constants.NATIVE_TOKEN_ADDRESS, // ETH on zkSync
buyAmountWei: BigInteger.Parse("0.1".ToWei()),
sender: await Utils.GetAddressFromENS(client, "vitalik.eth"),
receiver: await myWallet.GetAddress()
);
Console.WriteLine($"Prepared Buy contains {preparedBuy.Transactions.Count} transaction(s)!");

Sell - Get a quote for selling a specific amount of tokens

var sellQuote = await bridge.Sell_Quote(
originChainId: 324,
originTokenAddress: Constants.NATIVE_TOKEN_ADDRESS, // ETH on zkSync
destinationChainId: 1,
destinationTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
sellAmountWei: BigInteger.Parse("0.1".ToWei())
);
Console.WriteLine($"Sell quote: {JsonConvert.SerializeObject(sellQuote, Formatting.Indented)}");

Sell - Get an executable set of transactions (alongside a quote) for selling a specific amount of tokens

var preparedSell = await bridge.Sell_Prepare(
originChainId: 324,
originTokenAddress: Constants.NATIVE_TOKEN_ADDRESS, // ETH on zkSync
destinationChainId: 1,
destinationTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
sellAmountWei: BigInteger.Parse("0.1".ToWei()),
sender: await Utils.GetAddressFromENS(client, "vitalik.eth"),
receiver: await myWallet.GetAddress()
);
Console.WriteLine($"Prepared Sell contains {preparedSell.Transactions.Count} transaction(s)!");

Transfer - Get an executable transaction for transferring a specific amount of tokens

Why not just transfer with the SDK? Stay tuned for webhooks, think direct payments!

var preparedTransfer = await bridge.Transfer_Prepare(
chainId: 137,
tokenAddress: Constants.NATIVE_TOKEN_ADDRESS, // ETH on zkSync
transferAmountWei: BigInteger.Parse("0.1".ToWei()),
sender: await Utils.GetAddressFromENS(client, "vitalik.eth"),
receiver: await myWallet.GetAddress()
);
Console.WriteLine($"Prepared Transfer: {JsonConvert.SerializeObject(preparedTransfer, Formatting.Indented)}");

Manual Execution

This is not production code, we're just showcasing some of the APIs that would help you execute and poll status here.

// You may use our extensions to execute yourself...
var myTx = await preparedTransfer.Transactions[0].ToThirdwebTransaction(myWallet);
var myHash = await ThirdwebTransaction.Send(myTx);
// ...and poll for the status...
var status = await bridge.Status(transactionHash: myHash, chainId: 1);
var isComplete = status.StatusType == StatusType.COMPLETED;
Console.WriteLine($"Status: {JsonConvert.SerializeObject(status, Formatting.Indented)}");
// Or use our Execute extensions directly to handle everything for you!

Managed Execution

The SDK comes with some extensions that you'll see on a lot of ThirdwebBridge objects, and the main one is Execute.

// Execute a prepared Buy
var buyResult = await bridge.Execute(myWallet, preparedBuy);
var buyHashes = buyResult.Select(receipt => receipt.TransactionHash).ToList();
Console.WriteLine($"Buy hashes: {JsonConvert.SerializeObject(buyHashes, Formatting.Indented)}");
// Execute a prepared Sell
var sellResult = await bridge.Execute(myWallet, preparedSell);
var sellHashes = sellResult.Select(receipt => receipt.TransactionHash).ToList();
Console.WriteLine($"Sell hashes: {JsonConvert.SerializeObject(sellHashes, Formatting.Indented)}");
// Execute a prepared Transfer
var transferResult = await bridge.Execute(myWallet, preparedTransfer);
var transferHashes = transferResult.Select(receipt => receipt.TransactionHash).ToList();
Console.WriteLine($"Transfer hashes: {JsonConvert.SerializeObject(transferHashes, Formatting.Indented)}");

Full Bridge .NET Reference

Links

.NET Release | NuGet Release | Unity Release
Documentation | Support

Greg

We've built Universal Bridge to allow your users to use any asset on any chain, and it's ready for you to try. If you're interested in joining the private beta for Universal Bridge, complete this form (or reach out to anyone from the thirdweb team).

Who's It For?

Do you need to accept fiat and crypto payments in your app? Are you struggling to find reliable onchain liquidity for swaps? Are you tired of implementing bespoke bridges for multiple chains? Universal Bridge is for you.

What Is It?

Bridging, swapping, and accepting payments each bring their own challenges. The existing options are unreliable, complicated, and reliant on poor design choices. Universal Bridge is the easiest way to route assets in your app. Swap tokens, bridge between chains, onramp assets, accept onchain payments, and more all with a simple, unified API.

We already support 30,000+ routes across 50+ chains and are adding more every day. We're running detailed routing and reliability tests across all of them to guarantee a great experience for users.

How's It Work?

Universal Bridge uses a combination of existing protocols and onramps with thirdweb's own onchain and off-chain infrastructure for maximum coverage and reliability. The result is a "best case scenario" for buying, selling, and transferring assets between any EVM chain.

How Can I Try It?

Our Private Beta starts today, and your app can be one of the first to use it. Just complete this form or reach out to anyone on the team to get access. Or, try the playground widget here.

Toomas Oosalu

We're excited to announce that thirdweb Insight has expanded its blockchain data querying capabilities to 67 chains, including these 7 new chains:

What This Means For Developers
With these additions, you can now use all of Insight's powerful features across these new chains.

Try them out on the playground!

View All Supported Chains
For a complete list of supported chains and their respective chain IDs, check the thirdweb chainlist.


📖 Learn more about Insight - it’s open source and ready to power your applications!

Arsenii

We've revamped our metadata storage and refresh mechanisms to provide a more reliable, scalable, and efficient experience when working with NFT collections metadata through Insight!

What’s New?

More Reliable Metadata Storage

  • Replaced the previous caching approach with a more permanent storage solution, ensuring faster retrieval and better consistency across requests.
  • Metadata is now stored and accessed in a way that eliminates potential inconsistencies, making it the single source of truth for retrieval.

Explicit Force Refresh Endpoints

To give developers more control, we’ve introduced dedicated API endpoints for refreshing metadata on demand:

  • Collection Metadata Refresh
    • GET v1/nfts/metadata/refresh/:contract_address
  • Token Metadata Refresh
    • GET v1/nfts/metadata/refresh/:contract_address/:token_id
  • Both endpoints fully support multichain operations via chain query parameters.
  • Refreshing token metadata also ensures collection-level metadata stays up to date.

Why This Matters

Improved Data Consistency – Eliminates mismatches between different layers, ensuring metadata stays accurate.
Simplified Architecture – No more juggling between temporary and permanent storage solutions.
Better Scalability – Optimized for large-scale metadata operations, enabling more efficient handling of growing datasets.
Multichain-Ready – Works seamlessly across chains, just like you’re used to.

What’s Next?

We’re actively working on further performance optimizations by consolidating multiple separate queries into more efficient, single-fetch operations. This will unlock even faster metadata retrieval without sacrificing accuracy. Stay tuned with more updates to thirdweb Insight! 🚀

Jake Loo

This new update includes several changes to the tools in thirdweb MCP (Model Context Protocol) Server – improving overall accuracy in tool selection and speed performance for some onchain queries.

Improvement and Fixes

  • Improved onchain query performance and tool selection
  • Fixed Engine service auth requests that were not configured properly
  • Updated thirdweb-ai to v0.1.4 (see full changelog)

A few prompts and guide to try out:

  • What is the price of ETH? or What is the price of UNI token?
  • Show me the recent events for 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 on Ethereum (1)
  • What are the recent transactions from 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 on Base (8453)?
  • What is the ABI of 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 on Ethereum (1)
  • Transfer 0.00001 ETH to 0xEb0effdFB4dC5b3d5d3aC6ce29F3ED213E95d675 on Sepolia (11155111)

Always provide a fully valid wallet address, and include chain id along with the chain name.

Upgrade Guide

# Using pipx
pipx upgrade thirdweb-mcp
# Using uvx
uvx --upgrade thirdweb-mcp
Jake Loo

This new update focuses on improving the accuracy of tool selection by consolidating tools, picking better default values, and giving developers the ability to override tool description prompts.

New Features

  • Override service tools' description prompts
from thirdweb_ai import Insight
insight = Insight(secret_key=...)
# using default tool description
tools = [insight.get_all_transactions()]
# using custom tool description
tools = [insight.get_all_transactions(description="Call this to fetch transactions for account")]

Improvements

  • Insight always requests with most recent and decoded data
  • Insight performance improvement by using the correct sort key
  • Updated resolve tool prompt to provide a more accurate description
  • Reduced number of tools with similar functionality:
    • Merged get_contract_abi into get_contract_metadata
    • Merged get_contract_events_by_signature into get_all_events

Bug Fixes

  • Fixed invalid auth for Engine requests due to headers not being set correctly
  • Fixed some invalid paths or bodies for Engine and Insight tools
  • Fixed improper schema error from OpenAI Agents adapter when a tool schema contains anyOf, oneOf, or allOf

Upgrade Guide

# pip
pip install thirdweb-ai --upgrade
# poetry
poetry update thirdweb-ai
# uv
uv add thirweb-ai --upgrade
Joaquim Verges

We just released a new live playground that lets you customize and interact with the Universal Bridge via the prebuilt UI component.

Try it out at: https://playground.thirdweb.com/connect/pay

The playground lets you customize:

  • Payment mode: fund wallets, direct payments or onchain transactions
  • Price, chain and token information
  • Payment methods
  • Metadata
  • Theme
  • Gas sponsorship

Every customization shows you the changes in a live preview, as well as the corresponding code to copy paste into your projects.

Happy building! 🛠️

Jake Loo

We're excited to announce the first release of thirdweb ai, a powerful Python library (TypeScript coming soon) that enables AI agents to interact with any EVM chains autonomously using thirdweb. This is a significant step forward in our mission to make web3 more accessible and empower developers to build the next generation of AI-powered onchain applications.

Why thirdweb ai?

As Large Language Models (LLMs) and AI Agents continue to evolve as transformative technologies, we recognized the need for these systems to interact with blockchain networks autonomously. We believe that giving AI agents the ability to perform onchain actions based on real-time data will unlock new possibilities.

What Can You Build?

With thirdweb ai, you can create AI agents that:

  • Manage wallets and transactions securely using Engine
  • Retrieve and analyze on-chain data in real-time using Insight
  • Delegate complex onchain executions to Nebula agents

All of this functionality integrates smoothly with the AI agent framework of your choice, including OpenAI Agents, LangChain, AgentKit, GOAT, AutoGen, LlamaIndex, and many more.

Getting Started

Installation

Install the core package with all adapters:

pip install "thirdweb-ai[all]"

Or choose specific framework adapters:

# For OpenAI Agents
pip install "thirdweb-ai[openai]"
# For LangChain
pip install "thirdweb-ai[langchain]"
# For AutoGen
pip install "thirdweb-ai[autogen]"
# For LlamaIndex
pip install "thirdweb-ai[llama-index]"
# For additional frameworks
pip install "thirdweb-ai[goat]"
pip install "thirdweb-ai[agentkit]"
pip install "thirdweb-ai[mcp]"
pip install "thirdweb-ai[smolagents]"
pip install "thirdweb-ai[pydantic-ai]"

See here for the full list of supported framework and installation guides.

Basic Usage

from thirdweb_ai import Engine, Insight, Nebula, Tool
# Initialize thirdweb services
insight = Insight(secret_key=...)
nebula = Nebula(secret_key=...)
engine = Engine(secret_key=..., engine_url=..., engine_auth_jwt=...)
# Get available tools
tools = [
# Access powerful web3 tools
# Optionally, select tool from each services
*insight.get_tools(), # Giving agents real-time on-chain data access
*engine.get_tools(), # Wallet and transaction management
*nebula.get_tools(), # Agent for complex blockchain tasks
]

Framework Integration Examples

OpenAI Agents

from thirdweb_ai import Tool
from thirdweb_ai.adapters.openai import get_openai_tools
# Initialize your thirdweb tools
tools = [...] # List of thirdweb tools
# Convert to OpenAI tools
openai_tools = get_openai_tools(tools)
# Use in your OpenAI Agent
agent = Agent("thirdweb_agent", tools=openai_tools, ...)

LangChain

from thirdweb_ai import Tool
from thirdweb_ai.adapters.langchain import get_langchain_tools
# Initialize your thirdweb tools
tools = [...] # List of thirdweb tools
# Convert to LangChain tools
langchain_tools = get_langchain_tools(tools)
# Use in your LangChain agent
agent = create_tool_calling_agent(tools=langchain_tools, ...)

Developer Resources

LLM Integration

When building applications that integrate LLMs with thirdweb's blockchain capabilities, you can enhance your results by including thirdweb context files:

Learn More

Get started with thirdweb-ai today and join us in building the future of onchain AI agents!

Joaquim Verges

We just shipped a big upgrade to partner management for ecosystems. You can now specify what type of signatures are permitted for each partner, as well as granular controls on what exactly can be signed. As an ecosystem owner, this means you have full control of what each partner is able to do with your user's ecosystem wallets, like restricting to particular assets or actions.

In your ecosystem dashboard, you'll find a new option for "Access Control" when you create or edit an ecosystem partner. You can setup these signing restrictions in 2 ways: your own server verification, or built in rules.

Server verification

This is the most flexible and powerful option - every signature request will flow through your own server and you get to perform your own logic for allowing or disallowing a particular signature.

server verifier setup

The response from your sever should just be a simple JSON body with the following format.

{
isAllowed: boolean;
reason?: string;
}

Built-in rules

You can also set your rules directly in the dashboard. These include what signature types you would like to allow, and granular permissions per signature type, like the chain, contract addresses or function selectors that are allowed to be called.

For ecosystems that use smart accounts, since those require personal_sign signatures, we've added a user operation filter that lets you control which smart account operations are allowed to be signed by the ecosystem wallets.

These controls are low level and powerful, letting you tightly control what can and cannot be done with wallets on a per-partner basis.

We're continuously improving this UI to make it easier for ecosystem owners to setup these rules. Your feedback is appreciated and help us make this product better for everyone!

Vernon Johnson

We're excited to announce improvements to our Token and NFT APIs in Insight. We've recently added support to get all token transfers by owner, wallet, and token contracts. We've also included in this release major performance improvements to existing NFT endpoints.

The following endpoints are now available to use.

Get NFT Transfers by Wallet

GET https://{chain}.insight.thirdweb.com/v1/nfts/transfers?owner_address={owner_address}

Retrieve all NFT transfers by wallet address. Supports ERC1155 and ERC721.

Get Transfers by Contract

GET https://{chain}.insight.thirdweb.com/v1/tokens/transfers/{contract_address}

Get all token transfers for a contract address. Supports ERC20, ERC1155, and ERC721.

Get Transfers by Wallet

GET https://{chain}.insight.thirdweb.com/v1/tokens/transfers?owner_address={owner_address}

View all token transfers for a wallet address. Supports ERC20, ERC1155, and ERC721.

Get Transfers by Transaction

GET https://{chain}.insight.thirdweb.com/v1/tokens/transfers/transaction/{transaction_hash}

Get all token transfers in a transaction. Supports ERC20, ERC1155, and ERC721.

Resources

Jonas Daniels

With the latest dashboard update, users can now view their invoices directly in thirdweb for easy management.

  • Invoice history, amount, and details are available at a glance.
  • Download the full invoice pdf document to see breakdown of charges by usage and plan.

To view your invoices, login to thirdweb and navigate to Settings > Invoices.

For any feedback or support inquiries, please visit our support site.

Arsenii

We’re pleased to announce a more robust contract verification process, now featuring a dedicated Etherscan verification status check and final result reporting. This means you can confidently verify your contracts—proxy or otherwise—knowing you’ll receive a much more clear outcome every time.

Added Verification Status Check and Final Result Return

  • Introduced extra logic to check for verification status on Etherscan-like explorers, which polls for verification completion.
    • This now returns the final verification result (e.g., "success," "failure," or "already verified") instead of just the receipt GUID.

Fixed Constructor Parameter Fetching for Proxy Contracts

  • Fixed some corner cases where we should use the implementation address when verifying proxied contracts with constructor parameters.

We hope this streamlined verification workflow reduces the friction of contract verifications and helps you focus on delivering great applications. Happy building!

Nischit Pradhan

We're excited to announce an important update to our RPC edge infrastructure at thirdweb. This enhancement is designed to improve performance and reduce costs for our users.

🚀 What’s New?

  • Response Compression at RPC Edge:
    We’ve enabled response compression, meaning our RPC endpoints now deliver compressed responses to reduce data size and speed up transmission.
  • Cost Reduction for Users:
    With smaller payloads, users can enjoy reduced bandwidth usage and lower overall costs when interacting with our servers.
  • New Request Requirement:
    To take full advantage of this update, you need to add an Accept-Encoding header to your requests. This tells our servers that your client can handle compressed responses.

🛠️ How to Use the New Feature

Simply include the Accept-Encoding header in your API requests. For instance, if you're calling the eth_blockNumbermethod using our RPC endpoint, you can use the following curl example:

curl -H "Content-Type: application/json" \
-H "Accept-Encoding: gzip" \
-d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
https://1.rpc.thirdweb.com

In this example:

  • The Accept-Encoding: gzip header signals that your client accepts gzip-compressed responses.
  • The JSON payload makes a call to eth_blockNumber to retrieve the latest block number.

🎉 Conclusion

This update is part of our continuous effort to enhance performance and efficiency. We’re committed to providing you with the best tools and infrastructure for your development needs. If you have any feedback or questions, please don’t hesitate to reach out.

Toomas Oosalu

We're excited to announce that thirdweb Insight has expanded its blockchain data querying capabilities to 61 chains, including these 19 new chains:

What This Means For Developers
With these additions, you can now use all of Insight's powerful features across these new chains.

Try them out on the playground!

View All Supported Chains
For a complete list of supported chains and their respective chain IDs, check the thirdweb chainlist.


📖 Learn more about Insight - it’s open source and ready to power your applications!

Manan Tank

You can now view the list all sponsored transactions across in a team by going to your Team > Usage Page in thirdweb dashboard

You can also view this table in your Team > Project > Connect > Account Abstraction > Analytics page to see only sponsored transactions for the selected project

Greg

The thirdweb SDK comes with built-in tree-shaking, meaning your application only keeps what it uses from the SDK. However, we still like to keep the overall package size as small as possible for convenience while you're running your application in development. With version 5.92.0 we've reduced the package install size by more than 25%, from 199 MB to 144 MB. See the latest here.

MediaRenderer Changes

Unfortunately, this means we've had to remove support for 3D models in the media renderer. You can still display 3D model NFTs in your application using our IPFS resolvers and Three.js or a similar library.

Vernon Johnson

We're excited to announce the release of additional NFT API endpoints to Insight. These endpoints provide comprehensive APIs for accessing NFT metadata, transfers, ownership information, and more. The NFT API provides a great alternative for developers looking to migrate from SimpleHash, which is expected to shutdown on March 27th.

The endpoints below are now available to use.

NFT Tokens API

Get NFTs by Contract

GET https://{chain}.insight.thirdweb.com/v1/nfts/{contract_address}

Retrieve all NFTs from a specific contract address.

Get NFT by Token ID

GET https://{chain}.insight.thirdweb.com/v1/nfts/{contract_address}/{token_id}

Fetch data for a specific NFT using its contract address and token ID.

Get NFTs by Owner

GET https://{chain}.insight.thirdweb.com/v1/nfts?owner_address={owner_address}

List all NFTs owned by a specific wallet address across all contracts.

NFT Transfers API

Get NFT Transfers by Contract

GET https://{chain}.insight.thirdweb.com/v1/nfts/transfers/{contract_address}?metadata=true

Track all transfer events for a specific NFT contract with optional metadata.

Get NFT Transfers by Token

GET https://{chain}.insight.thirdweb.com/v1/nfts/transfers/{contract_address}/{token_id}?metadata=true

View the complete transfer history for a specific NFT token with optional metadata.

Get NFT Transfers by Transaction

GET https://{chain}.insight.thirdweb.com/v1/nfts/transfers/transaction/{transaction_hash}?metadata=true

Retrieve all NFT transfers that occurred within a specific transaction with optional metadata.

NFT Ownership API

Get NFT Owners by Contract

GET https://{chain}.insight.thirdweb.com/v1/nfts/owners/{contract_address}

List all current owners of NFTs from a specific contract.

Get NFT Owners by Token

GET https://{chain}.insight.thirdweb.com/v1/nfts/owners/{contract_address}/{token_id}

Identify the current owners of a specific NFT token.

Resources

Jake Loo

We’re excited to introduce significant upgrades Nebula's transaction execution. Our latest model, t0-003, is more capable, accurate, and intelligent—enabling seamless execution of complex, multi-step prompts.

With expanded support for bridging, swapping, and multi-transaction workflows, developers can now perform actions like retrieving balances, executing transfers across chains, and handling approvals in a single streamlined process.

Improvements

  • New model: t0-003 — more capable, higher accuracy and smarter
    • Supports complex prompts that involve multi-step instructions
    • For example:
      get the usdc balance for thirdweb.eth on ethereum, then transfer that amount to jakeloo.eth on base
  • Bridging and swapping with more chains and more token routes supported
    • Supports multiple transactions, for example, approve and transfer. Wallets will need to execute the transactions in order.
    • The chat completion API may consist of multiple unsigned_transaction in the actions

Nebula is currently in Alpha for a select number of developers. For access to the product, please sign up on the Nebula waitlist.

For any feedback or support inquiries, please visit our support site.

Toomas Oosalu

Querying token prices in USD is now supported by Insight API!

Try it out in our playground

To fetch a token's price by its contract address

(0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee is used for native tokens)

const getPrice = async () => {
try {
const response = await fetch(
"https://1.insight.thirdweb.com/v1/tokens/price?address=0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
{
headers: {
"x-client-id": <THIRDWEB_CLIENT_ID>,
},
},
);
const priceData = await response.json();
return priceData.data;
} catch (error) {
console.error("Error:", error);
}
};

Response

[
{
chain_id: 1,
address: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
symbol: 'ETH',
price_usd: 2192.917084798869,
price_usd_cents: 219291
}
]

You can optionally define a timestamp and the API will return the closest data it has to that timestamp.

const getPrice = async () => {
try {
const ts = Date.now() - 3 * 60 * 60 * 1000; // 3 hours ago
const response = await fetch(
`https://1.insight.thirdweb.com/v1/tokens/price?address=0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee&timestamp=${ts}`,
{
headers: {
"x-client-id": <THIRDWEB_CLIENT_ID>,
},
},
);
const priceData = await response.json();
return priceData.data;
} catch (error) {
console.error("Error:", error);
}
};

To fetch token prices by symbol

const getPriceBySymbol = async () => {
try {
const response = await fetch(
"https://1.insight.thirdweb.com/v1/tokens/price?symbol=ETH",
{
headers: {
"x-client-id": <THIRDWEB_CLIENT_ID>,
},
},
);
const priceData = await response.json();
return priceData.data;
} catch (error) {
console.error("Error:", error);
}
};

Note that there can be multiple tokens with the same symbol


We support more than 6000 tokens currently and keep adding more.

We also provide an endpoint to fetch the list of supported tokens for each chain.


📖 Learn more about Insight - it’s open source and ready to power your applications!

Toomas Oosalu

Insight API will deprecate all camelCase fields from responses and remove them by 30th of March 2025. Every field that was previously in camelCase has a duplicate field in snake_case for the time being, allowing users to migrate their response handling.

List of affected fields:

  • decodedData
    • New name: decoded
    • Affected endpoints
      • v1/transactions (in case of decode=true query param)
      • v1/transactions/:contractAddress (in case of decode=true query param)
      • v1/transactions/:contractAddress/:signature
      • v1/events (in case of decode=true query param)
      • v1/events/:contractAddress (in case of decode=true query param)
      • v1/events/:contractAddress/:signature
  • decodedData.indexedParams and decoded.indexedParams
    • New name: indexed_params
    • Affected endpoints
      • v1/events (in case of decode=true query param)
      • v1/events/:contractAddress (in case of decode=true query param)
      • v1/events/:contractAddress/:signature
  • decodedData.nonIndexedParams and decoded.nonIndexedParams
    • New name: non_indexed_params
    • Affected endpoints
      • v1/events (in case of decode=true query param)
      • v1/events/:contractAddress (in case of decode=true query param)
      • v1/events/:contractAddress/:signature
  • chainId
    • New name: chain_id
    • Affected endpoints
      • v1/tokens/erc20/:ownerAddress
      • v1/tokens/erc721/:ownerAddress
      • v1/tokens/erc1155/:ownerAddress
  • tokenAddress
    • New name: token_address
    • Affected endpoints
      • v1/tokens/erc20/:ownerAddress
      • v1/tokens/erc721/:ownerAddress
      • v1/tokens/erc1155/:ownerAddress
  • tokenId
    • New name: token_id
    • Affected endpoints
      • v1/tokens/erc721/:ownerAddress
      • v1/tokens/erc1155/:ownerAddress

Example of a decoded data response

// rest of response...
"decoded": {
"name": "Transfer",
"signature": "Transfer(address,address,uint256)",
// will be deprecated
"indexedParams": {
"from": "0x0000000000000000000000000000000000000000",
"to": "0x321b7ff75154472b18edb199033ff4d116f340ff"
},
"indexed_params": {
"from": "0x0000000000000000000000000000000000000000",
"to": "0x321b7ff75154472b18edb199033ff4d116f340ff"
},
// will be deprecated
"nonIndexedParams": {
"amount": 4843303142399797056
},
"non_indexed_params": {
"amount": 4843303142399797056
}
},
// rest of response...

It should be noted that the properties in indexed_params and non_indexed_params could be any format, because they are based on how the smart contract was programmed.

Example of a token response

// rest of response...
{
// will be deprecated
"chainId": 1,
"chain_id": 1,
// will be deprecated
"tokenAddress": "0xca8098ab4503aee15b3291d22c0852518d04da63",
"token_address": "0xca8098ab4503aee15b3291d22c0852518d04da63",
// will be deprecated
"tokenId": "78",
"token_id": "78",
"balance": "1"
},
// rest of response...

📖 Learn more about Insight - it’s open source and ready to power your applications!

Arsenii

We’re excited to share that Thirdweb now better aligns with Etherscan’s latest V2 API. If you regularly need to have your contracts verified on Etherscan-like explorers, this change means a more streamlined, less error-prone experience - so you can spend more time shipping, and less time wrestling with parameters. One click on the Thirdweb dashboard is all it takes!

What’s New

  • V2 API Readiness: Our system automatically targets Etherscan V2 endpoints for the correct chain, minimising manual setup and reducing the possibility of misconfiguration.
  • Future-Proofing: This approach lays the groundwork for supporting additional block explorer APIs with minimal friction, ensuring that Thirdweb utilities remains flexible and up-to-date.

Why It Matters

The goal behind these changes is to make verifying your smart contracts as hassle-free as possible. By cutting down on repetitive parameters and streamlining the integration with Etherscan V2, we’ve drastically reduced the chance of errors. Ultimately, we want you to focus on the things that matter—innovating, building, and delivering great blockchain experiences.

We’re always improving our developer experience, so if you have any questions or feedback, reach out to us. In the meantime, we hope you enjoy the smoother, more robust contract verification process!

Amine Afia
Vernon Johnson

Insight now serves NFT assets through the Thirdweb Gateway, improving retrieval times by caching the content on a globally serving data on edge. Instead of referencing IPFS or Arweave links, insight automatically resolves them to edge-friendly endpoints, so metadata no longer displays IPFS URLs. This deployment works seamlessly with the existing NFT schema without requiring any additional steps. It enhances performance, reduces latency, and ensures consistent, high-speed access to decentralized assets.

Example:

before:

"image_url": "ipfs://QmY1vKaHd3UvbzStxgndUMH3FzprK7jTJcAvgbHbcLsZXv/107.png"

After

"image_url": "https://5c9e93b8acbb5d972c1841911a7dce5f.ipfscdn.io/ipfs/QmY1vKaHd3UvbzStxgndUMH3FzprK7jTJcAvgbHbcLsZXv/107.png"

This means you can use the image directly in your frontend, the snippet bellow would render the NFT image from thirdweb gateway.

<img src="https://5c9e93b8acbb5d972c1841911a7dce5f.ipfscdn.io/ipfs/QmY1vKaHd3UvbzStxgndUMH3FzprK7jTJcAvgbHbcLsZXv/107.png" alt="NFT Image" />
NFT Image
Jake Loo
Samina Kabir

Effective Date: March 3, 2025, at 3:00 PM PST

Announcing some important changes to our mint fee process that further standardize our fee structure for all new contract deployments. We are introducing a 1% protocol fee applied to all contracts, and adjusting the convenience fee to 1.5% from previous 2.5%.

We believe this change strikes the right balance between a standardized protocol fee and the flexibility for custom fee settings, making fee management easier and more transparent for everyone.

Please note this change does not effect already deployed contracts.

What’s Changing?

  • Fixed protocol fee:
    All new deployments now include a non-overridable 1% protocol fee. This fee is implemented into the contract and will always apply if deployed through SDK, dashboard, or third-party integrations. For example, an asset listed at 0.1 ETH will distribute 0.099 ETH to the seller and 0.001 ETH to the platform.
  • Convenience Fee:
    When deploying via dashboard, the fee includes a 1.5% convenience fee or 2.5% total (1% protocol fee plus an additional 1.5%). For example, an asset listed at 0.1 ETH will distribute 0.0975 ETH to the seller and 0.0025 ETH to the platform.
  • Custom Fee Configuration:
    You can still set your own platform fee during deployment or later via our platform. The process works exactly as before, with the custom fee now being applied in addition to the fixed thirdweb fee.

Why the Change?

This adjustment helps support continued development and maintenance of prebuilt smart contracts, ensuring reliability, security, and innovation for the ecosystem.

For any questions or further details, please reach out to our support team.

FAQs

  • Which prebuilt contracts will have included fees?
    • The following contracts and corresponding modular versions will now include a seller fee:
      • Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
      • Token Contracts: TokenERC20, TokenERC721, TokenERC1155
      • Specialized Contracts: LoyaltyCard, BurnToClaim, MarketplaceV3
  • I deployed a contract prior to the effective date, will these fees apply to me?
    • This fee is only applied to any contracts deployed after 3:00 pm PST on March 3, 2025
Amine Afia

We Introduced a new include_spam query parameter to the ERC20 token endpoint to filter out potential spam tokens.

GET /v1/tokens/erc20/vitalik.eth&include_spam=true

The criteria for identifying spam include:

• Empty token name

• Empty token symbol

• Symbol length greater than 15 characters

• Zero decimals

By default, spam tokens are excluded from responses (include_spam=false). You can try it in our playground by visiting here. See the example bellow:

Here is a Typescript example showing how to use it in your code:

fetchTokens = async () => {
try {
const response = await fetch(
"https://1.insight.thirdweb.com/v1/tokens/erc20/vitalik.eth?metadata=true&include_spam=true",
{
headers: {
"x-client-id": clientId,
},
},
);
const tokensResult = await response.json();
return tokensResult;
} catch (error) {
console.error("Error:", error);
}
};
Toomas Oosalu

We are now supporting NFT metadata for Insight NFT balance endpoints (ERC-721 and ERC-115).

By adding metadata=true query parameter to the request, the response will include metadata about the NFT - name, description, image URL, background color, external URL, collection and contract info in addition to the balance.

Here's an example of the data that can be returned:

{
"chainId": 137,
"tokenAddress": "0x819384ee58c4aadcf170a78728addafb6301d871",
"tokenId": "3907",
"balance": "1",
"name": "Cloude Doodle #3907",
"description": "The Doodle Cloud Kingdom is an ally of the Bekantan Kingdom to defend and show strength.",
"image_url": "ipfs://QmVCu8NRuKUb64jDQqg3fsPrXa19W37Y7Cx2Vo8C5fdZe5/3907.png",
"extra_metadata": {
"dna": "20a571eaae29e115ed30716bf4282f7663ab3f7c",
"edition": 3907,
"date": 1660320491602,
"attributes": [
{
"trait_type": "Background",
"value": "Gradient (55)"
},
{
"trait_type": "Body",
"value": "Cumulos (61)"
},
{
"trait_type": "Hat",
"value": "Bando (7)"
},
{
"trait_type": "Mouth",
"value": "Stoic"
},
{
"trait_type": "Eyes",
"value": "Villain"
},
{
"trait_type": "Nose",
"value": "Disgusted (57)"
}
],
"compiler": "HashLips Art Engine"
},
"collection": {
"name": "Cloude Doodle"
},
"contract": {
"type": "ERC721",
"name": "Cloude Doodle",
"symbol": "CLD"
}
}

Try it out on our playground

Or call it directly from code

const getNFTsWithMetadata = async (address: string) => {
try {
const response = await fetch(
`https://1.insight.thirdweb.com/v1/tokens/erc721/${address}?metadata=true`,
{
headers: {
"x-client-id": <your-client-id>,
},
},
);
const response = await response.json();
return response;
} catch (error) {
console.error("Error:", error);
}
};

📖 Learn more about Insight - it’s open source and ready to power your applications!

Vernon Johnson

The Insights API now supports querying contract metadata and ABIs. Powered by our contract indexing and verification backend, developers can now access verified contract metadata and ABIs for all supported chains directly within Insights. This eliminates the need to interact with block explorers and third party source code verifiers to get contract metadata and ABIs.

We've added the following endpoints:

Get contract ABI

curl https://insight.thirdweb.com/v1/contracts/abi/0x66a9893cc07d91d95644aedd05d03f95e1dba8af?chain=1&clientId=THIRDWEB_CLIENT_ID

Get contract ABI

Get contract ABI

Get contract metadata

curl https://insight.thirdweb.com/v1/contracts/metadata/0x66a9893cc07d91d95644aedd05d03f95e1dba8af?chain=1&clientId=THIRDWEB_CLIENT_ID

Get contract metadata

Get contract metadata

Both endpoints are available in the playground to test.

Stay tuned for more updates and exciting features from Thirdweb!

Arsenii

We’re excited to unveil a powerful addition to the thirdweb platform: a brand-new API designed to automate chain onboarding in real time. This release is especially useful for Rollup-as-a-Service (RaaS) providers, who can now seamlessly integrate new chains into the thirdweb ecosystem the moment they’re spun up. No more back-and-forth or manual listing processes—this API provides a streamlined way to manage your chains on thirdweb.

What’s New?

  1. Automated Registration of Newly Spun-Up Chains
    Our new API endpoints let you programmatically add or update chain configurations on the thirdweb platform. This is critical for RaaS providers who rapidly deploy new chains and need an immediate, frictionless connection to thirdweb.
  2. Seamless Integration with Existing Workflows
    Because the API is designed for simplicity, it easily slots into your existing DevOps workflow. You can add a single API call to your chain deployment scripts, automatically informing thirdweb about the new chain’s details—no manual steps required.
  3. Real-Time Updates
    Once your chain is registered, the thirdweb platform reflects the changes immediately, so developers can start using thirdweb tools (SDKs, CLIs, and dashboards) on your newly created chains right away.
  4. Robust Documentation and Tooling
    We’ve launched an accompanying API Reference that covers everything you need—from authenticating requests to building complex integration flows. You’ll find clear examples, success and error response codes, and best practice guidelines.

Key Endpoints at a Glance

Below are some of the most commonly used endpoints. A full list of endpoints and usage examples can be found in the API docs.

  • POST /chains
    Register a new chain with thirdweb. Supply essential metadata (e.g., chain name, chain ID, explorer URLs, stack type and custom RPC urls) for immediate onboarding.
  • GET /chains
    Fetch details about chains added by your team. Useful for verifying that your chains has been successfully added and has all the relevant info present.
  • PUT /rpcUrls/{chainId}
    Add RPC urls for an existing chain, very requested by RaaS providers.

Why This Matters for RaaS Providers

  • Speedy Deployment: Spin up a new rollup chain and instantly register it with thirdweb in a single automated step.
  • Less Overhead: No more waiting on manual reviews or dealing with miscommunications. Your chain data stays in sync whenever you roll out a new version or fork.
  • Scalability: Whether you have one chain or a thousand, the API is built to handle bulk provisioning and updates.

How to Get Started

  1. Review the Documentation
    Check out the API docs for quickstart guides and detailed references.
  2. Generate an API Key
    Obtain an API key from your thirdweb dashboard. This key will authenticate your requests.
  3. Integrate With Your Deployment Scripts
    Add API calls to your RaaS deployment pipeline or CI/CD workflow to register new chains automatically.
  4. Test & Monitor
    Use the provided sandbox environment or your standard staging area to test new chain registrations before rolling out changes to production.

Looking Ahead

We’re committed to making thirdweb the most developer-friendly platform for emerging blockchain solutions. Here’s a sneak peek at what’s coming next:

  • Account Abstraction
    Automate provisioning and integration with your custom account abstraction flows for enhanced security and better user experiences.
  • Universal Bridge (previously thirdweb Pay)
    Simplify asset transfers across different chains with an automatically provisioned, interoperable payment/bridge layer.
  • Insight
    Gain real-time analytics and diagnostics across all your chains—insightful dashboards and metrics will be automatically enabled for new rollups.

Expect these features—along with additional endpoints, analytics hooks, and security enhancements—to be part of our continued effort to streamline multi-chain support.

Stay tuned for details and in the meantime, don't hesitate reaching out to get early access and needed permissions to be able to utilise this and give us feedback!


As always, thank you for building with thirdweb!

Amine Afia

We’re introducing metadata retrieval in our ERC20 token API!

You can now include token information—such as name, symbol, and decimals—in a single call to our /tokens/erc20 endpoint. Just add the new metadata=true parameter to the query string. For example:

GET /v1/tokens/erc20/vitalik.eth&metadata=true

This returns the token’s metadata along with the usual balance data, simplifying your workflows and saving you from making extra calls. We’ve also added caching so metadata lookups are faster after the first request.

You can try it in our playground by visiting here. See the example bellow:

Here is a Typescript example showing how to use it in your code:

const search = async () => {
try {
const response = await fetch('https://1.insight.thirdweb.com/v1/tokens/erc20/vitalik.eth?metadata=true', {
headers: {
"x-client-id": clientId,
},
});
const tokensResult = await response.json();
return tokensResult
} catch (error) {
console.error('Error:', error);
}
};
Toomas Oosalu

Insight API added support for querying block data.

Try it out on our playground

Or use it directly from code

const getBlock = async (blockNumber: number) => {
try {
const response = await fetch(
`https://1.insight.thirdweb.com/v1/blocks?filter_block_number=${blockNumber}&limit=1`,
{
headers: {
"x-client-id": <your-client-id>,
},
},
);
const blockResponse = await response.json();
return blockResponse.data[0];
} catch (error) {
console.error("Error:", error);
}
};

📖 Learn more about Insight - it’s open source and ready to power your applications!

Toomas Oosalu

Insight API now supports an explorer-like endpoint to resolve blockchain data.

The resolve endpoint supports

  • Transaction hashes - returns the transaction data
  • Block hashes - returns the block data
  • Addresses (also ENS names)
    • In case of an EOA - returns last 20 transactions from that address
    • In case of a contract - returns last 20 transactions to that address
  • Event signatures - returns the latest 20 events with the given signature
  • Function signatures - returns the latest 20 transactions with the given signature

Try it out on our playground

Or use it directly from code

const resolve = async () => {
try {
const response = await fetch('https://1.insight.thirdweb.com/v1/resolve/0xe01d4a0dbd117152f14c081a8b91b4f55429c469e2dc1530ea00d2714c6bb2a8', {
headers: {
"x-client-id": clientId,
},
});
const result = await response.json();
return result
} catch (error) {
console.error('Error:', error);
}
};

This endpoint was initially called v1/search/:input but was changed to v1/resolve/:input to better reflect its purpose.


📖 Learn more about Insight - it’s open source and ready to power your applications!

Nischit Pradhan

At thirdweb, innovation is in our DNA. We’re excited to share a behind-the-scenes look at how our team is continuously pushing the boundaries to deliver an unparalleled user experience. Today, we're diving into some key upgrades that have transformed our RPC server.

🍞 Embracing the Bun Runtime

We’ve made a bold move by switching our RPC server to the Bun runtime. This isn’t just a technological upgrade—it’s a leap toward efficiency. With this change, we’ve managed to slash memory usage by 30%. What does that mean for you? More network requests are handled seamlessly, ensuring a smoother and more responsive experience without the need for extra hardware.

⚡ Turbocharged with Short-term Caching

Performance matters, and every millisecond counts. By introducing short-term caching into our architecture, we’ve dramatically reduced latency. Our metrics tell the story:

  • P90 latency is down by 50%.
  • P95 latency has improved by a whopping 300%.

These numbers translate into faster response times and a more robust service, even during peak usage periods.

🔍 Deep-Dive Monitoring with Enhanced APM

Understanding every nuance of our system is key to delivering excellence. We’ve integrated fine-grained our Performance Monitoring that drills down into every RPC call. This means we now track method-level usage and latency, giving us a crystal-clear view of performance across the board. With this insight, we’re empowered to act swiftly, optimizing our service before issues can arise.

Firekeeper

What's Changed

Insight Indexer .NET Integration

Insight is an extremely useful and performant tool to query blockchain data and can decorate it quite nicely too.

Did you know that vitalik, on Ethereum, Polygon and Arbitrum alone owns 7811 ERC20s, 34,362 ERC721s and 2,818 ERC1155s?
Let's go through some examples!

Instantiation

using Thirdweb.Indexer;
// Create a ThirdwebInsight instance
var insight = await ThirdwebInsight.Create(client);

Simple Args

// Setup some filters
var address = await Utils.GetAddressFromENS(client, "vitalik.eth");
var chains = new BigInteger[] { 1, 137, 42161 };

Fetching all tokens owned by a given address

// Fetch all token types
var tokens = await insight.GetTokens(address, chains);
Console.WriteLine($"ERC20 Count: {tokens.erc20Tokens.Length} | ERC721 Count: {tokens.erc721Tokens.Length} | ERC1155 Count: {tokens.erc1155Tokens.Length}");

Fetching a specific type of token owned by a given address

// Fetch ERC20s only
var erc20Tokens = await insight.GetTokens_ERC20(address, chains);
Console.WriteLine($"ERC20 Tokens: {JsonConvert.SerializeObject(erc20Tokens, Formatting.Indented)}");
// Fetch ERC721s only
var erc721Tokens = await insight.GetTokens_ERC721(address, chains);
Console.WriteLine($"ERC721 Tokens: {JsonConvert.SerializeObject(erc721Tokens, Formatting.Indented)}");
// Fetch ERC1155s only
var erc1155Tokens = await insight.GetTokens_ERC1155(address, chains);
Console.WriteLine($"ERC1155 Tokens: {JsonConvert.SerializeObject(erc1155Tokens, Formatting.Indented)}");

Fetching Events
Note: most of these parameters are optional (and some are not showcased here)

// Fetch events (great amount of optional filters available)
var events = await insight.GetEvents(
chainIds: new BigInteger[] { 1 }, // ethereum
contractAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", // bored apes
eventSignature: "Transfer(address,address,uint256)", // transfer event
fromTimestamp: Utils.GetUnixTimeStampNow() - 3600, // last hour
sortBy: SortBy.TransactionIndex, // block number, block timestamp or transaction index
sortOrder: SortOrder.Desc, // latest first
limit: 5 // last 5 transfers
);
Console.WriteLine($"Events: {JsonConvert.SerializeObject(events, Formatting.Indented)}");

Full Insight .NET Reference

Engine Blockchain API .NET Integration

Engine is one of thirdweb's most important products. We've created an EngineWallet class that can be used as an IThirdwebWallet and as such benefits from being compatible with the entire SDK!

Usage:

// EngineWallet is compatible with IThirdwebWallet and can be used with any SDK method/extension
var engineWallet = await EngineWallet.Create(
client: client,
engineUrl: Environment.GetEnvironmentVariable("ENGINE_URL"),
authToken: Environment.GetEnvironmentVariable("ENGINE_ACCESS_TOKEN"),
walletAddress: Environment.GetEnvironmentVariable("ENGINE_BACKEND_WALLET_ADDRESS"),
timeoutSeconds: null, // no timeout
additionalHeaders: null // can set things like x-account-address if using basic session keys
);
// Simple self transfer
var receipt = await engineWallet.Transfer(chainId: 11155111, toAddress: await engineWallet.GetAddress(), weiAmount: 0);
Console.WriteLine($"Receipt: {receipt}");

Integrated with last December's EIP-7702 release!

Additional Changes

  • Arbitrum, Arbitrum Nova and Arbitrum Sepolia gas price related methods now get shortcut early and return maxFeePerGas = maxPriorityFeePerGas = current gas price.
  • Utils.GetChainMetadata chain id related variables updated from int to BigInteger.

Links

.NET Release | NuGet Release | Unity Release

Documentation | Support

Manan Tank

Collaborating with your team just got easier! You can now invite new members and manage existing ones directly from your dashboard.

This feature is available to all "Starter", "Growth" and "Pro" plan customers today.

Example

Invite new members in your team

  • Invite single or multiple team members via email
  • Assign roles during the invitation process 

Manage team members

  • View all team members and their assigned roles.
  • Remove team members when needed
  • Search, filter, and sort team members for easy management

Monitor your Invites

  • Track all pending and expired invites
  • Delete an invite to revoke the invitation before it is accepted

Try it out

Go to thirdweb dashboard > Your Team > Settings > Members page

Toomas Oosalu

Insight API now supports Ethereum Name Service (ENS) names in address fields. You can use ENS names instead of raw Ethereum addresses when querying API endpoints.

Try it out on our playground

Vitalik's Ethereum ERC-20 tokens

Or use it directly from code

const getVitalikTokensOnEth = async () => {
try {
const response = await fetch('https://1.insight.thirdweb.com/v1/tokens/erc20/vitalik.eth', {
headers: {
"x-client-id": clientId,
},
});
const balances = await response.json();
return balances
} catch (error) {
console.error('Error:', error);
}
};


📖 Learn more about Insight - it’s open source and ready to power your applications!

Toomas Oosalu

We’ve made significant enhancements to thirdweb Insight, allowing you to efficiently query ERC-20, ERC-721, and ERC-1155 token balances for any address.

Faster Queries on Large Chains

We identified latency issues on bigger chains where some requests took over 10 seconds.
Our improved indexing logic has reduced p99 query latency to under 1.5 seconds across all chains.
This is just the first step and we'll keep on improving the performance of Insight

Want to try it out? All endpoints are available on our playground: ERC-20 queries, ERC-721 queries and ERC-1155 queries.

Or integrate them into your app:

const getVitalikNftsOnBase = async () => {
try {
const response = await fetch('https://8453.insight.thirdweb.com/v1/tokens/erc721/0xd8da6bf26964af9d7eed9e03e53415d37aa96045', {
headers: {
"x-client-id": clientId,
},
});
const balances = await response.json();
return balances
} catch (error) {
console.error('Error:', error);
}
};


📖 Learn more about Insight - it’s open source and ready to power your applications!

Toomas Oosalu

Insight open source indexer has received it's first major version upgrade in beta to 1.0.2-beta and brings with it more scalable reorg handling, better reliability and more performance.

New Features

  • Token Balances API endpoint - The indexer API now has a new `/balances/:owner/:type` endpoint to retrieve token balances by type (ERC20, ERC721, ERC1155) for a specified address. Added features include aggregation support, customizable responses, and options for pagination and filtering.
  • Materialized views for token balances - Created materialized views to keep track of token balances as logs are being inserted.
  • Chain based table configuration for Clickhouse - when using Clickhouse as a data store, you can now configure table names and default columns.
  • Field selection for storage connectors - Specific fields can be fetched via storage connectors to not query everything and improve performance.

Reliability and Performance

  • Improved reorg handling with Clickhouse data store - Migrated database tables to use `VersionedCollapsingMergeTree` for better data accuracy and scale when indexing multiple chains.
    NB! This is a breaking change!
  • Added serialization for API responses with specific column selection to better control the data returned. Also replaced array-based topics in logs with fixed columns for more reliable data handling.
  • Enhanced committing integrity - added safeguards to track the last committed block, preventing data inconsistencies and duplicate insertion.
  • Graceful shutdown - Implemented context cancellation for all orchestrator components to support graceful shutdown, improving application reliability during deployment disruptions.
  • GetTraces Consistency - Updated trace fetching logic to conform to API standards and enabling consistent pagination and filtering across the codebase

This update introduces substantial improvements in API functionality and performance, database consistency, and overall reliability. These changes facilitate better integration, data retrieval, and system robustness, especially in cloud-deployed environments.

Learn more about Insight and how to use it.
Insight is open source.

Joaquim Verges

We're creating the next evolution of thirdweb Pay with Universal Bridge.

Coinbase onramp provider

You can now onramp with over 40 fiat currencies to any token using just a credit card. This gives your users zero fees on select currencies, and no KYC required for low amounts.

0:00
/0:09

1,000 new routes added

We've added new chains and new tokens available to bridge and swap. Over 1000 routes were added and more coming.

10x faster quotes

We're working on improved infrastructure to provide up to 10x faster quotes! These improvements will steadily roll out over the coming weeks.

UI Component improvements

We've been refining the UI of our prebuilt PayEmbed for all use cases: top up, commerce and transactions. Improvements include: showing fiat values next to token value everywhere, refined token selection flow, better error messaging and more.

0:00
/0:32
Firekeeper

Core Updates

  • Updated Thirdweb Rust static libraries to v1
    • In-App Wallets now have near 1:1 functionality with Ecosystem Wallets and share the same infrastructure.
    • Existing wallets will be automatically migrated to the new enclave infrastructure upon first login if needed.
  • Smart Wallet Factory improvements
    • Factory address is now stored on creation, eliminating the need for repeated declarations in nodes.
  • Write Contract node enhancements
    • Now implemented as a K2Node, allowing for raw data input via JSON.

Fixes & Optimizations

  • File length constraint fixes
    • Renamed all async tasks to comply with Epic's new 170-character file length rule, which previously caused issues due to plugin name hashing.
  • Unreal Engine Version Specific Compilation Issues
    • Added various conditional imports to additional headers resolving version-specific compilation issues.
  • Bug fixes
    • Fixed an issue where abstract class instantiation was attempted from Blueprints; now properly using the HasDedicatedNode meta tag.
    • Resolved an Android packaging error with the Thirdweb plugin in UE 5.4.
    • Fixed a crash on startup when packaging for Mac.
    • Fixed Write Contract ExpandNode Error.
    • Removed Chromium Embedded Framework (CEF) and related project settings.
    • Fixed multiple compilation, build, and packaging issues.

Quality of Life Improvements

  • Improved Examples
    • Updated samples to use the latest fixed nodes.
  • DX improvements
    • Various enhancements to Thirdweb editor utilities.
  • Other updates
    • Updated copyright to 2025.

Links

Unreal Engine v2.0.0 | Fab Marketplace (May not be up to date at the time of reading this, if that is the case, build from our github source!)

Documentation | Support

Yash Kumar

You can now use thirdweb dashboard to deploy contracts deterministically (create2) on multiple EVM chains.

To use this feature, deploy any thirdweb prebuilt or a custom contract using thirdweb dashboard. Then navigate to the Cross chain tab on contract page as shown below:

Use the dropdown to select the chain you wish to deploy on. Then click on Deploy button.

Once the contract gets deployed (or if it's already deployed at that address), the status will change to Deployed and you can click the link as shown above to navigate to that chain's contract page.

This feature is available for all thirdweb prebuilt contracts as well as custom contracts that are deployed / published using thirdweb tools. All direct deploy contracts (i.e. not proxy) must be deployed deterministically to enable this feature.

Note: this feature is available only for EVM chains

Go ahead and deploy a contract here.

Manan Tank

All Deployed Contracts Are Now Assigned to Projects

Previously, the thirdweb dashboard only allowed you to import contracts, without the ability to associate them with specific projects. Contracts were displayed as a single list across teams, projects, and account pages.

Now, you can organize your contracts within projects for better management.

As part of this update, all your deployed contracts have been automatically added to all your projects. You can now review each project and keep only the relevant contracts by removing others from the project

Project Contracts

Easily Add Contracts to Projects

Deploy & Add to Project

When deploying a new contract, you can now add it to a project immediately.

Deploy a Contract + Add To Project

Add Any Contract to a Project

Existing contracts can be added to projects with the new "Add to Project" button on the contract details page. Here's Doodles NFT contract for example:

Effortless Contract Management

Unlike the previous "Import to Dashboard" and "Remove from Dashboard" actions, adding or removing contracts from a project no longer requires signing a message.

Published Contracts Relocated

The Published Contracts page has been removed from the Teams and Projects pages and is now accessible via your Wallet profile page. A Link to the wallet profile page is also added in the Account Management Dropdown as shown below

Here's the thirdweb.eth profile page for example

Firekeeper

What's Changed

  • Smart Wallet transaction receipt polling can now time out based on your client "Other" timeout options, similar to normal transactions.
  • Our dashboard now supports rotating your secret keys. Rotated secret keys are now supported in this version.
  • You can now call InAppWallet or EcosystemWallet's Create function and instantly login with a twAuthTokenOverride which would be an auth token/cookie that you would have retrieved from any other thirdweb app, such as a web app, electron launcher, or any app built using our various SDKs.
var forwardedWallet = await InAppWallet.Create(
client: myClient,
authProvider: AuthProvider.Github,
twAuthTokenOverride: "my.auth.token"
);

Previously, it was only possible to go from .NET to other React apps using GenerateExternalLoginLink, this unlocks the other way.

Links

.NET Release | NuGet Release | Unity Release

Documentation | Support

Jake Loo
Samina Kabir

Effective Date: February 11, 2025, at 2:00 PM PST

Since launching in 2021, over 2 million smart contracts have been deployed with our toolkit — powering billions of transactions every year. We’re making some changes to our fee structure to better support the development of our smart contract development toolkit.

Starting on the effective date, a 2.5% platform fee (applied to both native and ERC20 tokens) will be introduced for all prebuilt contracts deployed through the thirdweb dashboard after 2 pm PST on February 11, 2025.

Please note this change does not effect already deployed contracts.

Which contracts have a fee?

This change applies to any contracts that have a primary sale recipient, including but not limited to:

  • Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
  • Token Contracts: TokenERC20, TokenERC721, TokenERC1155
  • Specialized Contracts: , LoyaltyCard, BurnToClaim, MarketplaceV3

How the Fee Works

  • The 2.5% fee will be automatically deducted from primary sales executed through these contracts. For example, an asset listed at 0.1 ETH will distribute 0.0975 ETH to the seller and 0.0025 ETH to the platform.
  • The fee applies only to prebuilt contracts deployed via the thirdweb dashboard. Custom contracts or externally deployed contracts remain unaffected.
  • The fee is charged from the primary sale, including a claim or mint action when there is a price on the NFT (non-zero). The fee is paid in the same currency as the claiming or minting price.

Why This Change?

This adjustment helps support continued development and maintenance of prebuilt smart contracts, ensuring reliability, security, and innovation for the ecosystem.

For any questions or further details, please reach out to our support team.

FAQs

  • Which prebuilt contracts will have included fees?
    • The following contracts and corresponding modular versions will now include a seller fee:
      • Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
      • Token Contracts: TokenERC20, TokenERC721, TokenERC1155
      • Specialized Contracts: LoyaltyCard, BurnToClaim, MarketplaceV3
  • I deployed a contract prior to the effective date, will these fees apply to me?
    This fee is only applied to any contracts deployed after 2 pm PST on 2/10/2025.
  • Can I opt out of the changes?
    • This change only applies to contracts deployed via the dashboard and not any contracts deployed programatically.
Prithvish Baidya

This release introduces a powerful credential management system and adds support for Circle's Web3 Services wallets. Circle, known for USDC and trusted by major financial institutions, provides institutional-grade wallets with bank-level security and SOC certifications - perfect for teams that need robust security assurance and regulatory compliance.

New Credential Management System

Managing cloud credentials across multiple wallets has always been a pain point. We've fixed that with a new credential system that brings enterprise-grade security features to your wallet infrastructure.

What's awesome about it:

  • Easy Rotation: Update credentials for multiple wallets at once by rotating their shared credential - perfect for regular security maintenance
  • Security at Scale: All wallets using the same credential automatically inherit security updates and policy changes
  • Audit Superpowers: Easily track which wallets are using which credentials for security reviews and compliance
  • Emergency Ready: Quick response to security incidents by updating credentials across all affected wallets simultaneously
💡
Currently, the credentials system has been rolled out for Circle wallets only. Default credentials are coming soon. Don't worry - your existing wallets will continue to work exactly as they do now.

Circle Developer-Controlled Wallets

We've added support for Circle's w3s developer-controlled wallets, bringing enterprise-grade signing capabilities to Engine. These wallets integrate seamlessly with our new credential management system and existing Engine infrastructure for transaction management.

Try It Out

Upgrade to engine v2.1.32, then try creating a smart backend wallet backed by Circle:

POST /wallet-credentials
{
"type": "circle",
"label": "my-circle-credential",
"entitySecret": "..."
}

Create a Circle Wallet Credential

POST /backend-wallet/create
{
"type": "smart:circle",
"credentialId": "..."
}

Use Circle Wallet Credential to create a Circle powered Smart Backend Wallet

Learn more about the entitySecret and how to create one from the Circle docs.

Take a look at our docs to learn more about configuring Engine to support Circle wallet, and check out our API Reference for detailed documentation and more examples.

What's Next?

We're working on expanding the credential system to support more wallet types and rolling out default credentials. Stay tuned for updates!

We're working on expanding support for more institutional wallet providers. Using Fireblocks, Copper, or another institutional wallet provider? We want to hear from you! Let us know which integrations would help your team ship faster.

Got questions? Join our Discord or check out the documentation.


thirdweb Engine is an open-source server for your app to read, write, and deploy contracts at production scale. Self-host for free or get a cloud-hosted Engine for $99/month.

Jake Loo
Samina Kabir

This update brings natural language support for token swapping and bridging, expanded access to offchain knowledge, and improved session context management.

New Features

  • Added support for swapping and bridging tokens in natural language
    • Example → "Swap 1 USDC to 1 USDT on the Ethereum Mainnet" or "Bridge 0.5 ETH from Ethereum Mainnet to Polygon"
  • Added more support for offchain knowledge including research headlines and articles about tokens or protocols
    • Example → “Tell me more about $UNI project”
  • Support for updating context using the /session/{session_id} endpoint
    • Example,
{
"message": "Hello Nebula!",
"context": {
"session_id": "...",
"wallet_address": "0x...",
"chain_ids": ["1", "11155111"]
},
}

Nebula is currently in Alpha for a select number of developers. For access to the product, please sign up on the Nebula waitlist.

For any feedback or support inquiries, please visit our support site.