Changelog

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

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.

• 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

• 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

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}`,
);

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
}

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,
});

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");
}

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."
}

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";

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.

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.

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

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)}");

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)!");

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)}");

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)!");

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)}");

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!

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

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

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).

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.

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.

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.

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.

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

• Sonic testnet
• Scroll
• Linea
• Zero mainnet
• Zero testnet
• Blast
• Mode

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!

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!

• 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.

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.

✅ 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.

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! 🚀

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

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

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! 🛠️

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.

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.

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.

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.

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
]

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, ...)

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, ...)

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

• Basic context: https://portal.thirdweb.com/llms.txt
• Comprehensive context: https://portal.thirdweb.com/llms-full.txt

• Check out our GitHub repository for more examples

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

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.

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.

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

{ 
  isAllowed: boolean;
  reason?: string;
}

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!

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 https://{chain}.insight.thirdweb.com/v1/nfts/transfers?owner_address={owner_address}

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

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 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 https://{chain}.insight.thirdweb.com/v1/tokens/transfers/transaction/{transaction_hash}

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

• Token API Docs
• NFT API Docs
• Playground
• SimpleHash Migration Guide

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.

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!

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.

• 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.

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.

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.

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

• zkSync
• Mantle
• Abstract mainnet and testnet
• Zora
• World
• Hedera
• Laos
• Rivalz
• Basecamp
• Beam
• Sonic
• Cronos zkEVM
• Taiko mainnet and testnet
• Celo testnet
• Arena Z testnet
• Treasure Topaz testnet
• Monad testnet

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!

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

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.

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.

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.

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

Retrieve all NFTs from a specific contract address.

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 https://{chain}.insight.thirdweb.com/v1/nfts?owner_address={owner_address}

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

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 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 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.

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

List all current owners of NFTs from a specific contract.

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

Identify the current owners of a specific NFT token.

• NFT API Docs
• Playground
• SimpleHash Migration Guide

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.

• 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.

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!