Changelog

Joaquim Verges

We've improved our wallet service for in-app and ecosystem wallets with new quality of life features. Below are the highlights and detailed changes.


✨ Highlights

  • Account deletion flag – allow end‑users to erase their wallet account entirely when unlinking the final auth profile.
  • Improved partner attribution – new user records created via an ecosystem partner are now tagged, and filtering is supported via the API.
  • Phone‑login sandboxing – deterministic phone/O​TP pair for local development and App Store / Play Store review flows.

1 · Full Account Deletion When Unlinking the Last Profile

Apple and other platforms mandates an way to delete user accounts.
You can now fulfill this requirement by setting allowAccountDeletion: true when unlinking the final profile tied to a wallet.

React Hook (useUnlinkProfile)

import { useUnlinkProfile } from "thirdweb/react";
const { mutate: unlinkProfile } = useUnlinkProfile();
const handleUnlink = () => {
unlinkProfile({
client,
profileToUnlink: connectedProfiles[0],
allowAccountDeletion: true, // Deletes the account if it's the last profile
});
};

Direct Function (TypeScript SDK)

import { unlinkProfile } from "thirdweb/wallets/in-app";
await unlinkProfile({
client,
profileToUnlink: profiles[0],
allowAccountDeletion: true, // Deletes the account if it's the last profile
});

2 · Better Ecosystem‑Partner Attribution

  • Automatic tagging – Any new wallet created through an ecosystem partner is now associated with that partner ID. (Existing users remain unchanged.)
  • Filtering – Query only the users for a given partner by providing both headers:
x-ecosystem-id: <your‑ecosystem‑id>
x-ecosystem-partner-id: <partner‑id>

GET /v1/users now returns only the wallets originated by that partner when both headers are present.


3 · Easier Local Testing for Phone‑Number Login

For staging or App Store submission, you may use the dedicated test credentials:

FieldValue
Phone+11111111111
OTP0000

These bypass SMS delivery so you can validate the flow end‑to‑end without external dependencies.


Feedback

As always we appreciate your feedback – drop us a line or open an issue on GitHub.


© 2025 Thirdweb

Joaquim Verges

v5.102.0 of the thirdweb TypeScript SDK rolls out server-side wallet orchestration and better transaction management—adding APIs to create & list server wallets, search transactions with flexible filters, batch multiple calls in one shot, and clearer error reporting.

Engine.createServerWallet()

Create a new server wallet with a custom label.

import { Engine } from "thirdweb";
const serverWallet = await Engine.createServerWallet({
client,
label: "My Server Wallet",
});
console.log(serverWallet.address);
console.log(serverWallet.smartAccountAddress);

Engine.getServerWallets()

List every server wallet that already exists.

import { Engine } from "thirdweb";
const serverWallets = await Engine.getServerWallets({
client,
});
console.log(serverWallets);

Engine.searchTransactions()

Search transactions by ID, chain ID, sender, and more (supports nested AND/OR filters).

// By transaction IDs
const transactions = await Engine.searchTransactions({
client,
filters: [{ field: "id", values: ["1", "2", "3"] }],
});
// By sender and chain
const transactions = await Engine.searchTransactions({
client,
filters: [
{
filters: [
{
field: "from",
values: ["0x1234567890123456789012345678901234567890"],
},
{ field: "chainId", values: ["8453"] },
],
operation: "AND",
},
],
pageSize: 100,
page: 0,
});

serverWallet.enqueueBatchTransaction()

Queue multiple transactions in a single batch and wait for completion.

// Prepare transactions
const tx1 = claimTo({ contract, to: firstRecipient, quantity: 1n });
const tx2 = claimTo({ contract, to: secondRecipient, quantity: 1n });
// Enqueue batch
const { transactionId } = await serverWallet.enqueueBatchTransaction({
transactions: [tx1, tx2],
});
// Wait for the batch to finish
const { transactionHash } = await Engine.waitForTransactionHash({
client,
transactionId,
});
console.log(transactionHash);

Improved Error Reporting

Server-wallet transactions now surface clearer, more actionable error messages.

Amine Afia

We’ve just shipped a powerful new feature to the Insight dashboard: Webhooks.

This release makes it easier than ever for developers to listen to blockchain events and transactions in real time — and trigger actions when they matter most.

Whether you’re building dashboards, automation workflows, or real-time alerts, Webhooks give you the tools to keep your system tightly synced with on-chain activity.


📡 What Are Webhooks?

Webhooks let you subscribe to blockchain activity and receive notifications when specific events or transactions occur — directly to your own application.

They’re ideal for:

  • Tracking contract events (e.g. transfers, mints, executions)
  • Monitoring transactions
  • Building alerting and analytics pipelines
  • Powering downstream workflows from blockchain data

Events are delivered in batches, with at-least-once delivery and unique event IDs for easy deduplication. We recommend using a queue system if your processing is heavy.


✨ What’s New in the Insight Dashboard

The new Webhooks UI brings a fully integrated way to manage everything — no manual setup or API-only workflows.

🧠 Webhook Management Features:

  • Create Webhooks
  • Filter by Contract, Event Signature, or Function Selector
  • Automatic ABI fetching to enable decoded data at delivery
  • Test Mode to verify endpoints before going live
  • List & Delete existing webhooks with full error and loading states
Arsenii

We just turbo-charged the aggregate parameter across the whole Playground:

BeforeAfter
Plain, lonely text area that expected you to hand-type SQLish expressions.A slick pop-over multi-select with popular presets and a free-form box for anything custom.

What’s new

  • Aggregate Parameter Input v2
    • Brand-new component for aggregate parameters input.
    • Pop-over UI with search, check-boxes, and live badges so you can combine multiple presets in one click.
    • Works anywhere aggregate is supported – Blocks, Transactions, Events, Wallet Transactions.
  • Preset library out of the box
    • Transaction Count, Total Value, Avg Value, Total Fees … plus contextual sets for each endpoint.
    • Custom SQL-like snippets still welcome—type them right alongside the presets.
  • Smarter parameter section
    • Descriptions & examples now auto-swap based on the parameter name for clearer guidance.
    • Place-holders use the parameter’s real description if one exists.

Docs, too 📚

Full walkthroughs, FAQs, and copy-paste code samples added to the relevant docs sections, such as Get Started, Use Cases, Blueprints, etc.

Under the hood

  • Replaced the plain old input field with a polished multifunctional pop-over.
  • State sync so manual edits and preset picks never collide.
  • Cleaner tooltip positioning and internal refactor of ParameterSection.

Enjoy faster insights without memorising SQL! Let us know what you build.

Toomas Oosalu

NFT owner queries have been improved with added balance data and a new ERC20 token owners endpoint has been added to Insight API.

ERC20 Owners

v1/tokens/owners has been added to return a list of token owners with their balances.

Try it out on our playground.

NFT Owners

The two endpoints to query NFT owners (v1/nfts/owners/:contract_address and /v1/nfts/owners/:contract_address/:token_id ) now have the ability to return the balance of each owner in addition to owner addresses.

To enable it, use the query param include_balances=true when calling the endpoints. This will change the response format, so make sure it will not break your app!

The new response format will be an array of owner objects, for example:

{
"data": [
{
"chain_id": 1,
"token_address": "0x5bb3d01f32687f92f8636799687e55cba0627704",
"owner_address": "0x0000000000000000000000000000000000000001",
"token_id": "88",
"balance": "1"
},
...
]
}

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

Cillian Berragan

This release introduces new integrations to expand both thirdweb AI and thirdweb MCP capabilities with Google's Agent Development Kit (ADK), and adds support for thirdweb Engine Cloud, allowing for autonomous on-chain interactions.

Features

Google ADK Integration

  • Added Google Agent Development Kit (ADK) adapter support
  • Enables direct integration with thirdweb tools for use with ADK agents
  • Supports all thirdweb AI tools and thirdweb MCP
from google.adk.agents import Agent
from thirdweb_ai import Insight
from thirdweb_ai.adapters.google_adk import get_google_adk_tools
# Initialize Insight with secret key
insight = Insight(secret_key=secret_key, chain_id=1)
insight_tools = insight.get_tools()
# Convert to Google ADK tools
adk_tools = get_google_adk_tools(insight_tools)
# Create the agent with the tools
agent = Agent(
model="gemini-2.0-flash",
name="thirdweb_insight_agent",
tools=adk_tools,
)

Engine Cloud Service

  • Introduced dedicated Engine Cloud service integration
  • Supported in all AI integrations, and the thirdweb MCP server
  • Allows for autonomous on-chain executions like creating engine cloud wallets, and transacting on-chain
from thirdweb_ai import EngineCloud
# Initialize EngineCloud with credentials
engine_cloud = EngineCloud(
secret_key="your_secret_key",
vault_access_token="your_vault_token"
)
# Get cloud-based engine tools for AI integrations
tools = engine_cloud.get_tools()

MCP Integration

To run engine cloud within thirdweb MCP you must provide a vault_access_token:

THIRDWEB_SECRET_KEY=... \
uvx thirdweb-mcp --vault-access-token=...

This gives you access to Engine Cloud tools like creating wallets, or sending transactions.

thirdweb-ai and thirdweb-mcp v0.1.24 are both live now on PyPi!

Toomas Oosalu

Insight API adds a new token balances endpoint that also supports native token balances. It will replace the current ERC-20 balance endpoint which is being deprecated.

ERC-20 Balance Endpoint Deprecation

This endpoint is being deprecated in favor of v1/tokens to be better aligned with the NFT endpoints and make it easier to expand the capabilities of the new endpoint in the future.

New Tokens Endpoint

v1/tokens has full parity with the ERC-20 balances endpoint but also adds support for native token balances and also returns the owner_address in the response.

Native balances are always returned at the beginning of the response. If they are not needed, they can be removed from the response by setting the include_native query param to false.

The native token address is 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

The new endpoint is available in our playground.


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

Arsenii

We’ve improved the Insight API to support unified access to all token transfers — both NFTs (ERC721/ERC1155) and fungible tokens (ERC20) — through a single, consistent endpoint 🚀

Highlights:

  • You can now fetch NFT and ERC20 transfers in one call.
  • Transfer responses include metadata for both NFTs and ERC20 tokens.
  • Added support for a new "burn" transfer type when tokens are sent to the zero address.
  • Introduced filtering by token type (erc20, erc721, erc1155) via query parameters.

This change simplifies integration and improves performance when querying mixed token transfers — especially useful for clients who need a single endpoint to track all token activity.

Joaquim Verges

The thirdweb TypeScript SDK was just updated with significant updates to the universal bridge component and APIs.

Installation

pnpm add thirdweb@5.100.0

Highlights

No more insufficient funds walls

When you do a transaction in a react environment (useSendTransaction or TransactionButton), and the user does not have enough funds in their wallet, we now by default always show them a flow to top up their wallet:

  • Pay with another wallet
  • Pay with another token
  • Pay with fiat
  • Deposit funds (for testnets and unsupported routes) with balance auto refresh

PayEmbed improvements

The PayEmbed component has been improved across the board to load routes, quotes and status faster than ever before. No code changes required.

Bridge.Transfer – token transfers in one call

import { Bridge, NATIVE_TOKEN_ADDRESS, toWei } from "thirdweb";
const quote = await Bridge.Transfer.prepare({
chainId: 1,
tokenAddress: NATIVE_TOKEN_ADDRESS,
amount: toWei("0.01"),
sender: "0xSender",
receiver: "0xReceiver",
client,
});
// quote.transactions → execute sequentially with sendAndConfirmTransaction

Bridge.Onramp – fiat‑to‑crypto

import { Bridge } from "thirdweb";
import { ethereum } from "thirdweb/chains";
import { NATIVE_TOKEN_ADDRESS, toWei } from "thirdweb/utils";
const session = await Bridge.Onramp.prepare({
client,
onramp: "stripe",
chainId: ethereum.id,
tokenAddress: NATIVE_TOKEN_ADDRESS,
amount: toWei("10"),
receiver: "0xReceiver",
});
window.location.href = session.link;
// Later
const status = await Bridge.Onramp.status({ id: session.id, client });

Upgrade for smoother cross‑chain and on‑ramp experiences!

Cillian Berragan

Nebula 0.0.16 brings significant improvements to contract interactions, introduces a new token burn capability, and enhances cross-chain support.

Features

  • New Token Burn Tool: Permanently remove tokens from circulation with smart fallbacks. Supports both ERC20 tokens and native currencies, with automatic detection of burn methods.
  • Contract Type Detection: Automatically identify contract types (ERC20, ERC721, ERC1155, marketplace, proxy, multisig, etc.) to provide more context-aware interactions.
  • Enhanced Contract Metadata: Contract analysis now includes token-specific data (decimals, total supply), NFT-specific features (tokenURI support), and better handling of EOA addresses.
  • Improved Universal Bridge: Cross-chain transfers now work seamlessly across all supported chains with improved validation and confirmation.
  • Tool Consolidation: Combined similar tools (wallet address/token balance, transaction lookups) for more streamlined interactions and consistent responses.
  • Token-Specific Wallet Queries: Added support for querying specific token balances in a wallet, enabling more focused blockchain data retrieval.
  • Human-Readable Values: All token amounts now use human-readable formats with proper decimal handling across all contract tools.

Improvements

  • New Block Tool: New unified tool replaces separate block retrieval methods with support for block numbers, hashes, and special tags ('latest', 'earliest', 'pending').
  • Arbitrary Contract Output: Enhanced with additional metadata to support Nebula's response.
  • Link Formatting: Better formatting of transaction hashes and wallet addresses in responses for improved readability.

Bug Fixes

  • Fixed transaction data formatting in contract preparation tools
  • Corrected decimals handling in token operations
  • Improved URI formatting for NFT collections
  • Enhanced wallet address handling in transaction tools
Jake Loo

Overview

Nebula v0.0.15 focuses on enhancing contract metadata analysis and fixing core functionality issues. This release significantly improves contract metadata output, making it easier to understand smart contract functions and capabilities. It also fixes critical issues with address prediction and streaming responses.

Features

  • Enhanced Contract Metadata Tool: Completely revamped output format with better function categorization and improved contract type detection
  • Support for Code Block Streaming: Better handling of code snippets with proper formatting
  • Address and Transaction Links: Automatically creates clickable blockchain explorer links

Bug Fixes

  • Deploy Address Prediction: Fixed CREATE2 address calculation for cross-chain deployments
  • Streaming Response Buffering: Improved text streaming with better handling of code blocks
  • Transaction History: Re-added transaction lookup by hash to support transaction analysis
  • Image Rendering: Fixed generated images not showed up as an event

Try it out today at https://nebula.thirdweb.com!

Firekeeper

As soon as the Pectra Ethereum Upgrade was released, so were our next-gen 7702 smart accounts - read more about them here!

Today, we introduce support for more chains that upgraded to Pectra!

Ethereum: RPC and Chain Settings
Use the best Ethereum RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Gnosis: RPC and Chain Settings
Use the best Gnosis RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
BNB Smart Chain: RPC and Chain Settings
Use the best BNB Smart Chain RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
OP: RPC and Chain Settings
Use the best OP RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Base: RPC and Chain Settings
Use the best Base RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Ink: RPC and Chain Settings
Use the best Ink RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Unichain: RPC and Chain Settings
Use the best Unichain RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Zora: RPC and Chain Settings
Use the best Zora RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Soneium: RPC and Chain Settings
Use the best Soneium RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Mode: RPC and Chain Settings
Use the best Mode RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Scroll: RPC and Chain Settings
Use the best Scroll RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Gnosis Chiado Testnet: RPC and Chain Settings
Use the best Gnosis Chiado Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.
BNB Smart Chain Testnet: RPC and Chain Settings
Use the best BNB Smart Chain Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.
Zora Sepolia Testnet: RPC and Chain Settings
Use the best Zora Sepolia Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Soneium Minato: RPC and Chain Settings
Use the best Soneium Minato RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.
Mode Testnet: RPC and Chain Settings
Use the best Mode Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.
Scroll Sepolia Testnet: RPC and Chain Settings
Use the best Scroll Sepolia Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

TypeScript / React

// plain TypeScript
import { inAppWallet } from "thirdweb/wallets";
const wallet = inAppWallet({
executionMode: {
mode: "EIP7702",
sponsorGas: true,
},
});
// React (e.g. Next.js)
import { inAppWallet } from "thirdweb/wallets";
import { ConnectButton } from "thirdweb/react";
<ConnectButton
client={client}
wallets={[
inAppWallet({
executionMode: {
mode: "EIP7702",
sponsorGas: true,
},
}),
]}
/>;

.NET / Unity

// .NET (server, Godot C#, MAUI, etc.)
var smartEoa = await InAppWallet.Create(
client: thirdwebClient,
authProvider: AuthProvider.Google,
executionMode: ExecutionMode.EIP7702Sponsored
);
// Unity (C#)
var wallet = await ConnectWallet(
new WalletOptions(
provider: WalletProvider.InAppWallet,
chainId: 11155111,
inAppWalletOptions: new InAppWalletOptions(
authprovider: AuthProvider.Google,
executionMode: ExecutionMode.EIP7702Sponsored
)
)
);
Arsenii

We’ve re-architected how Insight webhooks are delivered — introducing a durable execution model that improves reliability, observability, and resilience.

🔂 Durable by Design

Webhook delivery is now handled through a stateful, retry-capable execution engine. This means:

  • Delivery persists through failures – Webhooks won’t silently fail or get lost due to transient issues.
  • Exponential backoff retries – Prevents overwhelming client systems while still ensuring delivery.

📈 Better Observability & Tracking

Every webhook delivery is now monitored and logged with structured metadata, giving us (and soon, you) much more insight into what’s happening:

  • Full delivery history and error context for each webhook delivery
  • Fine-grained attribution by webhook/project/team for improved debugging

⚙️ Configurable & Flexible

We've introduced configuration options that make it easier to tune webhook behavior per environment, including retry policies and timeouts.

🔮 What’s Next

This is just the beginning. Next up:

  • Durable storage for visualising webhook execution history and efficient retrieval of executions for a specific webhook
  • Improved webhook suspension management with visibility into paused endpoints
  • Self-serve observability tools so teams can view delivery status, retry logic, and failure patterns directly

If you rely on Insight webhooks to power workflows, this upgrade makes them more dependable and transparent.


Let us know what you'd like to see next → we're building this with you in mind.

Cillian Berragan

We're excited to announce a major upgrade to Nebula that introduces powerful new capabilities through the implementation of a code generation agent and real-time response streaming.

These changes are live now at nebula.thirdweb.com!

Overview

This release transforms Nebula with the integration of an agent that can generate code, enabling significantly more complex reasoning and multi-stage task processing. We've also added word-by-word streaming for a more responsive user experience, alongside numerous tool enhancements to support these new capabilities.

Powerful Multi-stage Processing

Replacing Nebula's main agent with a code-generation agent brings a revolutionary approach to how Nebula processes blockchain requests:

  • Code-first approach allows Nebula to write and execute Python code snippets for complex tasks
  • Enhanced reasoning capabilities for multi-stage blockchain operations
  • 30% more efficient processing compared to traditional tool-calling approaches
  • Improved problem decomposition for handling complex user requests

Now Nebula can automatically break down multi-stage operations like "Deploy a new ERC-721 contract, mint an NFT, and send it to cjber.eth" into logical steps with appropriate parameter validation at each stage.

Improved Thought Process Visibility

With Code Agent, Nebula now exposes more of its thinking process:

  • Watch as Nebula reasons through complex blockchain operations
  • See the logical steps it takes to solve multi-part problems
  • Better understand why specific approaches or parameters are used

This transparency helps users learn from Nebula's analytical approach while providing greater confidence in the recommended actions.

Word-by-word Response Generation

One of the most visible improvements in this release is the addition of real-time, word-by-word streaming:

  • Responses begin appearing immediately, eliminating long wait times
  • Thoughts and reasoning are streamed as they're generated
  • See Nebula work through complex problems in real-time

This creates a much more interactive experience, similar to watching an expert think through blockchain challenges.

Comprehensive Tool Enhancements

To support the new Code Agent architecture, we've made extensive improvements to Nebula's tool system:

Standardized Framework

  • Unified output formatting across all blockchain tools
  • Consistent validation patterns for blockchain parameters
  • Improved error handling with more descriptive messages

Enhanced Blockchain Operations

  • Consolidated related tools for more intuitive interactions
  • Better validation for blockchain addresses, amounts, and parameters
  • Improved handling of token standards and contract interactions

Performance Optimizations

  • More efficient tool execution for faster responses
  • Better handling of blockchain data pagination
  • Optimized resource usage for complex operations

What This Means For Users

These improvements deliver several key benefits:

  1. More Complex Tasks: Nebula can now handle significantly more complex, multi-stage blockchain operations
  2. Faster Responses: Start seeing results immediately with word-by-word streaming, and more efficient tool calling through code means overall response times are reduced

3. Better Reasoning Transparency: More visible reasoning helps users understand blockchain operations

  1. More Reliable Interactions: Enhanced validation ensures operations are checked thoroughly before execution

We're excited for you to experience the power of Code Agent and real-time streaming in Nebula. These improvements represent a significant leap forward in making blockchain interactions more intuitive, responsive, and powerful.

Ready to try out all these new features? Give it a spin at nebula.thirdweb.com!

Greg

We've added Transak to our suite of supported onramp providers in the Universal Bridge. Along with Coinbase and Stripe, Transak brings the total supported countries to over 160, and supported direct onramp tokens to over 170. Explore all the countries and tokens Transak supports.

When used with Universal Bridge, our onchain routing allows you to onramp to thousands of tokens. Some of the notable countries the Universal Bridge now supports:

  • Philippines
  • South Korea
  • Brazil
  • Japan
  • Indonesia
  • Hong Kong

Onramping with the API

To get an onramp link and quote using the Universal Bridge API, use the following:

const res = await fetch(
"https://bridge.thirdweb.com/v1/onramp/prepare",
{
method: "POST",
headers: {
"Content-Type": "application/json",
"x-secret-key": process.env.THIRDWEB_SECRET_KEY,
},
body: JSON.stringify({
onramp: "transak",
chainId: 4337,
tokenAddress: "0xAFf7314Bc869f4AB265ec7EfA8E442F1D978d7a",
maxSteps: 2,
amount: "200000000000000000",
currency: "USD",
receiver: "0x2a4f24f935eb178e3e7ba9b53a5ee6d8407c0709",
}),
},
);
const data = await res.json();

The returned quote will look something like this:

{
"data": {
"id": "3179cf89-e915-4103-b61e-991bf3a33e93",
"link": "https://global.transak.com/...",
"destinationAmount": "2000010000000000",
"timestamp": 1747165958956,
"expiration": 1747169558945,
"intent": {
"chainId": 4337,
"tokenAddress": "0xAff7314Bc869ff4AB265ec7Efa8E442F1D978d7a",
"amount": "2000010000000000",
"receiver": "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
"onramp": "transak",
"currency": "USD",
"maxSteps": 2
},
"steps": [
{
"originToken": {
"chainId": 4337,
"address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"symbol": "BEAM",
"name": "Beam",
"decimals": 18,
"priceUsd": 0.00974066,
"iconUri": "https://coin-images.coingecko.com/coins/images/32417/large/chain-logo.png?1698114384"
},
"destinationToken": {
"chainId": 4337,
"address": "0xAff7314Bc869ff4AB265ec7Efa8E442F1D978d7a",
"symbol": "FP",
"name": "Forgotten Playland",
"decimals": 18,
"priceUsd": 0.0006662,
"iconUri": "https://coin-images.coingecko.com/coins/images/35339/small/FP-Token-Icon_%281%29.png?1744266332"
},
"transactions": [
{
"type": "eip1559",
"to": "0xF8Ab2dBE6c43bf1a856471182290f91D621Ba76d",
"from": "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
"value": "142478928995176",
"data": "...",
"chainId": 4337,
"action": "buy",
"id": "0xb15a4e9999fc5504e64085dd812b33090e33e3b3b84f4d1adbaf52e6587af8f1",
"spender": "0x965B104e250648d01d4B3b72BaC751Cde809D29E"
}
],
"originAmount": "142478928995176",
"destinationAmount": "2000010000000000",
"estimatedExecutionTimeMs": 12000
}
],
"currency": "USD",
"currencyAmount": 1.06
}
}

You can then use the top-level id to get the onramp's status:

const res = await fetch(
"https://bridge.thirdweb.com/v1/onramp/status?id=3179cf89-e915-4103-b61e-991bf3a33e93",
{
method: "GET",
headers: {
"Content-Type": "application/json",
"x-secret-key": process.env.THIRDWEB_SECRET_KEY,
},
},
);
const data = await res.json();

The returned status:

{
"data": {
"status": "COMPLETED",
"transactions": [
{
"chainId": 4337,
"transactionHash": "0xd36a649a23044e980446a3183c6cfe9016d539a6ff88f31b611a1614b1d265aa"
}
],
"purchaseData": null
}
}

To learn more about how to use thirdweb's Universal Bridge for onramping, bridging, or swapping, check out the API reference or docs.

Greg

We've improved token balance fetching in the PayEmbed for near-instant balance display. We check thousands of tokens for possible routes and return any the user can use to perform their desired transaction in less than a second.

The improved performance is available as of TypeScript SDK v5.99.0. Try it out for yourself on the thirdweb playground.

0:00
/0:26
Joaquim Verges

Version 5.99.0 of the TypeScript thirdweb SDK brings first-class support for EIP-5792. The new implementation streamlines how you batch calls, sponsor gas and track confirmations, while aligning our API with the final EIP-5792 spec.

Highlights:

  • New React hooks – useSendAndConfirmCalls, useWaitForCallsReceipt
  • Simpler useSendCalls / sendCalls signatures – no more explicit client prop, aligned return types with v2.0.0 of the EIP
  • Decoupled receipt handling for flexible UI handling of receipts
  • Easy wallet-capability detection

Live Demo

As usual, you can try out the integration on the live playground:

0:00
/3:03

Usage

TypeScript (node / backend)

import { sendCalls, waitForCallsReceipt } from "thirdweb";
// Build your calls array (tx1, tx2 … conforming to EIP-5792 structure)
const result = await sendCalls({
calls: [tx1, tx2],
sponsorGas: true, // optional gas sponsorship
});
// Later - or in a different process
const receipt = await waitForCallsReceipt(result.id);
console.log("First tx hash:", receipt.receipts[0].transactionHash);

React (front-end)

1 – Fire-and-forget, then wait for the receipt

const { mutate: sendCalls } = useSendCalls();
const { data: result } = await sendCalls({ calls: [tx1, tx2] });
// later, or in another component
const { data: receipt, isLoading } = useWaitForCallsReceipt(
result.id,
);

2 – One-liner helper

const { mutate: sendAndConfirmCalls, data: receipt } =
useSendAndConfirmCalls();
await sendAndConfirmCalls({ calls: [tx1, tx2] });
console.log("Bundle confirmed:", receipt.bundleHash);

Breaking changes

The previous version of the SDK had beta support for 5792, which got some breaking changes in this version, listed below:

React

Before

After

useSendCalls({ client }) returned string bundleId

useSendCalls() returns { id, client, chain, wallet }

useSendCalls({ waitForBundle: true }) returned receipts

Waiting is now decoupled; use useWaitForCallsReceipt

N/A

New helper useSendAndConfirmCalls combines both steps

TypeScript / non-React

Before

After

type SendCallsResult = string;

type SendCallsResult = { id: string; client: ThirdwebClient; chain: Chain; wallet: Wallet }

getCallsStatus(bundleId)

getCallsStatus(id) (field renamed)

Any existing code that relies on the old return type must now read result.id and call waitForCallsReceipt (or the React hook) to obtain transaction receipts.

We recommend upgrading as soon as possible to leverage gas sponsorship and the simplified developer experience. For a full diff, see PR #7003 on GitHub.

Firekeeper

As soon as the Pectra Ethereum Upgrade was released, so were our next-gen 7702 smart accounts - read more about them here!

Today, we introduce support for more chains that upgraded to Pectra!

Arbitrum Sepolia: RPC and Chain Settings
Use the best Arbitrum Sepolia RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Base Sepolia Testnet: RPC and Chain Settings
Use the best Base Sepolia Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Soneium Minato: RPC and Chain Settings
Use the best Soneium Minato RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.
OP Sepolia Testnet: RPC and Chain Settings
Use the best OP Sepolia Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.
Unichain Sepolia Testnet: RPC and Chain Settings
Use the best Unichain Sepolia Testnet RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Ink Sepolia: RPC and Chain Settings
Use the best Ink Sepolia RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

TypeScript / React

// plain TypeScript
import { inAppWallet } from "thirdweb/wallets";
const wallet = inAppWallet({
executionMode: {
mode: "EIP7702",
sponsorGas: true,
},
});
// React (e.g. Next.js)
import { inAppWallet } from "thirdweb/wallets";
import { ConnectButton } from "thirdweb/react";
<ConnectButton
client={client}
wallets={[
inAppWallet({
executionMode: {
mode: "EIP7702",
sponsorGas: true,
},
}),
]}
/>;

.NET / Unity

// .NET (server, Godot C#, MAUI, etc.)
var smartEoa = await InAppWallet.Create(
client: thirdwebClient,
authProvider: AuthProvider.Google,
executionMode: ExecutionMode.EIP7702Sponsored
);
// Unity (C#)
var wallet = await ConnectWallet(
new WalletOptions(
provider: WalletProvider.InAppWallet,
chainId: 11155111,
inAppWalletOptions: new InAppWalletOptions(
authprovider: AuthProvider.Google,
executionMode: ExecutionMode.EIP7702Sponsored
)
)
);
Jake Loo

Overview

This release includes significant improvements to the Nebula agent's architecture, entity memory management, error handling, and documentation search capabilities. Key updates focus on simplifying blockchain entity handling, improving transaction management, supporting more content types in chat, and enhancing error messaging for a better user experience.

Features

  • New Content Support in Chat
    • Add support for image and transaction content types in chat messages
{
"messages": [
{
"role": "user",
"content": [
{ "type": "image", "image_url": "ipfs://Qmefr67P2qZS5BS9KBbZVgVXAYCdeezkN4je4tnd6xib4c" },
{ "type": "text", "text": "Please describe the image" }
]
}],
"stream": "true",
}
    • Enable transaction hash messages for blockchain status checks
{
"messages": [
{
"role": "user",
"content": [
{ "type": "transaction", "transaction_hash": "0x112c7d127dbd1fef1006aa6211462a2635b504fc42f71aad0cae4b1e7ddba32a", "chain_id": 1 }
]
}],
"stream": "true",
}
  • Enhanced Entity Management
    • Simplify loading entities by type with a cleaner implementation
    • Improve entity memory formatting for better readability
    • Reduce database operations for improved performance
    • Add user wallet as parsed entity for better context
  • Documentation and Search Improvements
    • Implement new LLMs documentation search with better context retrieval
    • Add URL to web search results for better source attribution
    • Format blockchain entities as links in responses
  • Improved Error Handling
    • Better error messaging for deployment and payment issues
    • Add instructions to help users correct chain context issues
    • Support graceful error handling in streaming responses

API Changes

  • New agent action types for better request handling
  • Support for image and transaction inputs in chat messages
  • More structured error responses with helpful suggestions
  • Revised agent action structure to use more specific types
  • Updated event streaming format for better client compatibility

Bug Fixes

  • Fix undefined behavior when no routes found in Universal Bridge
  • Handle payment required errors from storage service
  • Fix wallet balance formatting and improve entity display
  • Ensure price and token supply data is displayed correctly

Ready to try out all these new features? Give it a spin at https://nebula.thirdweb.com!

Greg

We just added Universal Bridge support for $HONEY, Berachain's stablecoin. You can now pay with or accept HONEY for any transaction on any chain.

0:00
/0:34
Joaquim Verges
Prithvish Baidya

Introducing Engine Cloud — read and write to the blockchain at scale, without the cost or complexity of traditional blockchain API setups.

Why we built Engine Cloud

Engine Cloud is our answer to lowering the barrier to developing high volume applications onchain- with fully-hosted, scalable APIs that let you perform on-chain actions from your backend. No upfront costs. Only pay-as-you-go.

It includes a non-custodial way to manage your wallets and ready-to-go API calls that do things like mint NFTs, transfer tokens, airdrops, sponsor gas for users — on any contract, across any EVM chain.

Engine Cloud includes:

  • Server Wallets managed via Vault (our new key management system)
  • New Transaction Gateway with retry logic, nonce management, and sub-second speed
  • New transaction API improved DX, new typescript SDK integration, and more
  • Secure, granular access tokens to work with multiple wallets and teams via vault access tokens and permissions
  • No more manual gas top-ups or alerts— we handle that for you by topping through our paymasters from your payment on file.

Learn more about use cases and benefits of using Engine Cloud.

Get Started

  1. Create a thirdweb project — this will include a ready-to-go Engine server for you to start making API calls on.
  2. Get your Vault Admin Key + Access Tokens — via the dashboard. Learn more about Vault.
  3. Create a server wallet — for secure, granular signing and management. You can create one or multiple server wallets.
  4. Start calling the API — write and send transactions from your backend using the simple API endpoints. All API endpoints can be accessed via the dashboard or through the API reference.

Engine will be free during beta without charging for any requests until May 19th. You can integrate it to your application today.

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

Samina Kabir

Say hello to Engine Cloud, the easiest way to send blockchain transactions from your backend at scale — no monthly fees, just pay-as-you-go.

  • Non-custodial wallet management - Manage through Vault, thirdweb's new Key Management Service
  • Avoid Transaction Failures – Resubmits stuck transactions with built-in retry logic
  • Wallet Management – No gas top-ups required; handle payments through your account
  • Abstract Blockchain Complexity – Sponsor gas + sign on behalf of users
  • Programmatic Deployments – Launch NFTs, tokens, accounts, marketplaces, and more

Get started by creating a project or try it out live on playground.

Learn more about Engine Cloud.

Joaquim Verges

EIP-7702 unlocks a new capability for externally-owned accounts (EOAs): the ability to behave like smart contract accounts. The latest SDK let you enable 7702 on any of your in-app wallets with one line of code, giving your users gas-sponsored, batched and automated transactions faster and more efficiently than ever before.

Why you’ll care

Once an in-app wallet is running in EIP-7702 mode you can:

Sponsor gas so users can sign transactions with zero ETH in their balance.
Batch transactions so multiple contract calls clear in a single signature.
Add session keys to automate on-chain actions safely (think scheduled mints, subscription based payments or game loops).
• …and any other capability you’d expect from smart accounts—all while your user keeps their familiar EOA address.

All it takes is a tiny config change.

But what about EIP-4337 smart wallets?
In our testing, using 7702 is up to twice as fast and orders of magnitude cheaper than using 4337 smart contract wallets!

Try it for yourself

Don't take our word for it, try it yourself on the live playground:

https://playground.thirdweb.com/connect/account-abstraction/7702


Using 7702 with In-App Wallets

In-app wallets lets you create wallets for your users based on standard logins like email, passkey or Google. Below are drop-in examples to turn those wallets into 7702 smart accounts for every stack the thirdweb SDK supports today.

TypeScript / React

// plain TypeScript
import { inAppWallet } from "thirdweb/wallets";
const wallet = inAppWallet({
executionMode: {
mode: "EIP7702",
sponsorGas: true,
},
});
// React (e.g. Next.js)
import { inAppWallet } from "thirdweb/wallets";
import { ConnectButton } from "thirdweb/react";
<ConnectButton
client={client}
wallets={[
inAppWallet({
executionMode: {
mode: "EIP7702",
sponsorGas: true,
},
}),
]}
/>;

. NET / Unity

// .NET (server, Godot C#, MAUI, etc.)
var smartEoa = await InAppWallet.Create(
client: thirdwebClient,
authProvider: AuthProvider.Google,
executionMode: ExecutionMode.EIP7702Sponsored
);
// Unity (C#)
var wallet = await ConnectWallet(
new WalletOptions(
provider: WalletProvider.InAppWallet,
chainId: 11155111,
inAppWalletOptions: new InAppWalletOptions(
authprovider: AuthProvider.Google,
executionMode: ExecutionMode.EIP7702Sponsored
)
)
);
Heads-up EIP-7702 only works on chains that enable it. Ethereum mainnet and Sepolia already support it, with more coming soon; keep an eye on the thirdweb blog for other chain activation dates.

Using EIP-7702 with External Wallets (EIP-5792)

Don’t want to embed an in-app wallet? No problem. EIP-5792 lets you tap into the same 7702 capabilities from any external wallet—like Metamask and Coinbase Wallet —via the sendCalls RPC method.

Sponsoring Gas & Batching Transactions

The useSendCalls React hook (or the plain sendCalls function in vanilla TypeScript) lets you bundle multiple calls into one and attach a paymaster so your dApp covers the gas:

import { useSendCalls } from "thirdweb/react";
const { mutate: sendCalls, data: bundleId } = useSendCalls();
await sendCalls({
client,
calls: [sendTx1, sendTx2],
capabilities: {
paymasterService: {
url: `https://${CHAIN.id}.bundler.thirdweb.com/${client.clientId}`,
},
},
});

Thie enabled single signature, gas-free, batched execution on exernal wallets like Metamask!

Documentation links: React API | TypeScript API

Ready to ship?

Upgrade your thirdweb SDK to the latest version, flip on executionMode: "EIP7702" or use EIP5792's sendCalls, and your users instantly level-up to smart-account features—no new wallets, no migrations, just better UX.

Got questions or feedback? Jump into the thirdweb Discord and let us know what you’re building!

Greg

With the latest release of Universal Bridge, we've added a number of new filters to make building advanced payment UIs more convenient. These are available starting in v5.97.0 of the TypeScript SDK.

The sortBy Filter

The /routes endpoint (API) and Bridge.routes function (SDK) now have an optional sortBy option to determine how the returned routes will be ordered. The first option we've made available is sortBy: "popularity", which will ordered the returned routes based on the number of times they've been used. The following will return the 10 most popular routes originating from ETH on mainnet:

import { Bridge } from "thirdweb";
const routes = await Bridge.routes({
originChainId: 1,
originTokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
limit: 10,
offset: 0,
sortBy: "popularity",
client: thirdwebClient,
});
[
{
"originToken": {
"chainId": 8453,
"address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
"iconUri": "https://coin-images.coingecko.com/coins/images/6319/large/usdc.png?1696506694",
"symbol": "USDC",
"name": "USD Coin",
"decimals": 6
},
"destinationToken": {
"chainId": 466,
"address": "0x675C3ce7F43b00045a4Dab954AF36160fb57cB45",
"iconUri": "https://coin-images.coingecko.com/coins/images/6319/large/usdc.png?1696506694",
"symbol": "USDC",
"name": "USD Coin",
"decimals": 6
}
},
{
"originToken": {
"chainId": 42161,
"address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
"iconUri": "https://ethereum-optimism.github.io/data/USDC/logo.png",
"symbol": "USDC",
"name": "USD Coin",
"decimals": 6
},
"destinationToken": {
"chainId": 466,
"address": "0x675C3ce7F43b00045a4Dab954AF36160fb57cB45",
"iconUri": "https://coin-images.coingecko.com/coins/images/6319/large/usdc.png?1696506694",
"symbol": "USDC",
"name": "USD Coin",
"decimals": 6
}
},
{
"originToken": {
"chainId": 1,
"address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"iconUri": "https://assets.relay.link/icons/1/light.png",
"symbol": "ETH",
"name": "Ether",
"decimals": 18
},
"destinationToken": {
"chainId": 8453,
"address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"iconUri": "https://assets.relay.link/icons/1/light.png",
"symbol": "ETH",
"name": "Ether",
"decimals": 18
}
},
...
]

The maxSteps Filter

The maxSteps filter already allows you to filter routes based on the number of steps required to fulfill a routes. With this update, we've added this same option to the Buy.quote, Buy.prepare, Sell.quote, and Sell.prepare functions, as well as their corresponding API endpoints. You can now guarantee the quote returned uses a certain number of steps or fewer:

import { Bridge } from "thirdweb";
const quote = await Bridge.Buy.quote({
originChainId: 1,
originTokenAddress: "0x...",
destinationChainId: 137,
destinationTokenAddress: "0x...",
amount: 1000000n,
maxSteps: 2,
});
const preparedQuote = await Bridge.Buy.prepare({
originChainId: 1,
originTokenAddress: "0x...",
destinationChainId: 137,
destinationTokenAddress: "0x...",
amount: 1000000n,
sender: "0x...",
receiver: "0x...",
maxSteps: 2,
});
const quote = await Bridge.Sell.quote({
originChainId: 1,
originTokenAddress: "0x...",
destinationChainId: 137,
destinationTokenAddress: "0x...",
amount: 1000000n,
maxSteps: 3,
});
const preparedQuote = await Bridge.Sell.prepare({
originChainId: 1,
originTokenAddress: "0x...",
destinationChainId: 137,
destinationTokenAddress: "0x...",
amount: 1000000n,
sender: "0x...",
receiver: "0x...",
maxSteps: 3,
});

The Chains Endpoint

We've added a new endpoint and SDK function to get all chains supported by Universal Bridge along with their name, icon, and native currency.

import { Bridge } from "thirdweb";
const chains = await Bridge.chains({
client: thirdwebClient,
});

This will return:

[
{
"chainId": 1868,
"name": "Soneium Mainnet",
"icon": "ipfs://QmPSGdP5WKe2bC5JCo43JjWff8Agw7dg6WQpmUktyW7sat",
"nativeCurrency": {
"name": "Ethereum",
"symbol": "ETH",
"decimals": 18
}
},
{
"chainId": 466,
"name": "AppChain",
"icon": "ipfs://bafybeigx76uxvcvet7365sjdzuxxcgl5auzck6vbbigu2jeg6ixl5k3tya",
"nativeCurrency": {
"name": "Ether",
"symbol": "ETH",
"decimals": 18
}
},
{
"chainId": 42161,
"name": "Arbitrum One",
"icon": "ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/arbitrum/512.png",
"nativeCurrency": {
"name": "Ether",
"symbol": "ETH",
"decimals": 18
}
},
...
]

Bug Fixes

  • Fixed an issue where Coinbase onramps were not returning the associated transaction hash
  • Fixed routes returning the zero address rather than the native token address
Jonas Daniels

You can now verify a domain for your team!

What’s new:

  • Teams can verify their domain (e.g. @yourcompany.com)
    → When logged in, navigate to Settings`→ General and scroll down Domain Verification to verify your domain.
  • To complete the verification, you'll need to add a DNS TXT record to your domain. This part must be completed through your domain provider's dashboard.
  • Please note you may only verify one domain per team.

Perks of verifying your domain:

  • Verified badge: Your team gets a special badge, so it’s easier to confirm you're in the right place.
  • Recommended team members: On the Settings → Members page, you’ll see users with emails that match your domain but aren’t in the team yet — making it super easy to invite everyone on the team.

Coming Soon:

  • Instant invite alerts: Team owners will get a notification (in the dashboard and optionally via email) when someone signs up with your verified domain — with a 1-click invite option.
  • Recommended teams for users: New users with a matching email domain will see teams they can request to join, giving team owners control to approve or deny.

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

Yash Kumar
Samina Kabir

In preparation for Ethereum’s upcoming Pectra upgrade this May, the thirdweb Pack contract has been officially deprecated and is no longer deployable via the dashboard, SDK, or CLI.

Important: Existing Pack contracts are not compatible with the Pectra upgrade.

We strongly recommend that users abandon or conclude any unopened packs as soon as possible to avoid potential issues once the upgrade goes live.

For any questions or support, please reach out to the official thirdweb team support channel.

Joaquim Verges

TL;DR: Update your SDK to 5.96.9+ to fix external wallet mobile connections.

A recent chrome update introduced a change in websockets that broke Wallet Connect connection flows on mobile. This resulted in users not being able to connect their wallets to mobile websites, infinitely loading. All wallet providers were affected. A bug fix was shipped by the Wallet Connect team to support the latest version of Chrome, and we immediately adopted the new version in the latest version of the thirdweb SDK.

Version 5.96.6 and above includes the fix, so update your library to resolve this issue.

Jake Loo

Overview

Nebula v0.0.12 brings significant improvements to the user experience and functionality. This release focuses on enhancing transaction management, adding support for NFTs and tokens, and improving the overall user interface. Key highlights include improved deployment workflows, better transaction formatting, and new token management capabilities.

Features

Memory management

    • More sophisticated entity tracking system
    • Better persistence of blockchain interactions
    • Enhanced context enrichment for more relevant responses

Token and NFT Management

  • Add ERC20 token transfer and approve functionality
    • Transferring tokens between addresses
    • Granting spending allowances to contracts
    • Add ERC721 transfer support for NFT management
  • Add minting capabilities
    • New NFT minting tool for creating digital collectibles
    • Token minting functionality with improved user feedback
  • Support for images in tokens and NFTs
    • Add rendering support for NFT and token images on the frontend

Transaction Improvements

  • Enhanced deployment workflows
    • Improve deployments to include more detailed information as markdown
    • Support multi-stage deployments for complex contract setups
    • Better UI feedback during deployment processes
  • Transaction array support
    • New functionality to handle batched transactions
  • Unify simulation and execution outputs
    • Consistent formatting for all transaction operations
    • Better readability of transaction details
  • Add rate limit checks to RPC calls
    • Prevent API throttling issues with improved handling

Bug Fixes

  • Fix native transfer rendering
    • Correct display of native token transfers in UI
  • Fix deploy UI issues
    • Address multiple UI bugs in the deployment interface
    • Fix early yielding creating duplicate UI cards
  • Fix contract output when metadata is missing
    • Better handling of contracts with missing information
  • Token Bridging / Swapping (Universal Bridge) fixes
    • Switch to new endpoints for improved reliability
    • Fix ABI handling for better contract interaction
  • Fix image parsing
    • Correct handling of image data in responses

Try it out today at https://nebula.thirdweb.com!

Toomas Oosalu

There are 2 changes to the Insight API to improve usability and fix a numeric overflow in Javascript.

Token & NFT Transfers

The NFT and Token transfer endpoints have been changed and now the owner_address query param is not mandatory anymore, enabling queries for all transfers on a chain.

Since this query can be heavy, we also added block number filters. You can narrow down the query using block_number_from and block_number_to query params.

Decoded Data Numeric Overflow Fix

Since Solidity supports numbers larger the Javascript's max number, APIs consuming the decoded events and transactions would receive some numeric values in scientific notation, losing precision.

We updated the decoded data to return large numeric values as string to prevent this. This is what a decoded transaction would look like now

{
"data": [
{
...rest of transaction...
"decoded": {
"name": "transfer",
"signature": "transfer(address,uint256)",
"inputs": {
"_to": "0x28c6c06298d514db089934071355e5743bf21d60",
"_value": "4179950264410000000000"
}
}
}
]
}

Note that the _value uint256 input is returned as string 4179950264410000000000


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

Jake Loo

Overview

This release introduces new image generation capabilities, improves error handling for rate limits, and fixes several key components including IPFS functionality and token minting. Performance optimizations have also been implemented to make token queries faster.

Improvements

  • Add image generation functionality - Implement new image generation capabilities. Create assets with generative artwork in a single prompt!
  • Improve rate limit handling - Add ability to gracefully abort execution when API rate limits are reached
  • Optimize token information retrieval - Add option to exclude price data for faster query performance

Try It Out!

Check it out at https://nebula.thirdweb.com

Joaquim Verges

The latest thirdweb typescript SDK release - v5.96.4 - adds a new way to make the Connect modal feel like your own by adding custom metadata to in-app wallets.

Wide mode

In wide mode, you can customize the name and icon of your in-app wallet in the list of wallets, and the image above the login options separately.

Compact mode

In compact mode, only the image above the login options is displayed.

How to setup your metadata

Simply pass your app metadata along the other options when creating your inAppWallet , then pass it as one of the available wallets in the ConnectButton or ConnectEmbed.

const wallets = [
inAppWallet({
// your auth options
auth: {
options: ["google", "x", "passkey"],
},
// your app metadata
metadata: {
name: "My App", // name for the wallet list
icon: "/twcoin.svg", // icon for the wallet list
image: {
src: "/twcoin.svg", // image above the login options
width: 100,
height: 100,
alt: "My App",
},
},
}),
createWallet("io.metamask"),
createWallet("com.coinbase.wallet"),
createWallet("io.rabby"),
];
<ConnectButton client={client} wallets={wallets} />;

Happy building! 🛠️

Jake Loo

Overview

This release focuses on improving reliability, performance, and user experience with several key enhancements:

  1. Universal Bridge: Enables bridge and swapping
  2. Search: Enhances search capability to improve onchain knowledge and optimizes thirdweb documentation search and access
  3. Contract Interaction: Simulates transactions result and improves contract information retrieval
  4. Performance: Improves contract interaction latency and performance

Improvements & Fixes

  • Improves token balance display with native token support
  • Fixes intermittent failure when interacting with newly deployed contracts
  • Improves error message formatting with actionable suggestions
  • Improves handling of missing contracts with better error messages
Jake Loo

This release significantly enhances Nebula's blockchain integration capabilities with a focus on improved multichain support, better token and NFT handling, and more robust authentication.

The model has been upgraded to provide more accurate and consistent responses more quickly. Users can now see the model's step-by-step thinking process as it performs tasks.

New approach to chain management. By default, only mainnet chains are enabled, to enable testnet requires setting context.networks = "testnet" in the /chat endpoint. The Chain IDs in the context may also be updated through conversations.

Breaking Changes 🔨

  • Model Updates: Experience more accurate and consistent responses with the improved t0_003 model.
  • Chain Management: Defaults to mainnet only. Enabling testnets require specific flag in the context. By setting, context.networks = "testnet"
  • Delegate Auth: Create a SIWE delegated auth tokens for scoped API access to chat and session.

Features ✨

Improvements

  • Guided Tool Prompts: More accurate tool selection by AI agents, resulting in fewer errors and more relevant responses.
  • Improved Output Consistency: More standardized and predictable response formats, making automated parsing of outputs more reliable.
  • Chain ID Parameter Prioritization: Explicit control over which blockchain they're interacting with, reducing confusion and errors from context-switching
  • Comprehensive Blockchain Data Retrieval: Access detailed information about blocks, transactions, and events, enabling more complex analyses within the tool.
  • Multi-chain Insight Support: Perform cross-chain operations and comparisons without needing to use separate tools or interfaces.
  • Domain Name Resolution: Interact with human-readable domain names (like ENS) instead of complex addresses, improving usability.
  • Human-readable Timestamps: See dates and times in standard formats rather than UNIX epochs, making information immediately understandable.

Token & NFT Support

  • Creating Assets: create different token standards (ERC20, ERC721, ERC1155) more easily.
  • NFT Collection Name Display: Friendly collection names rather than just contract addresses, making NFT identification more intuitive.
  • Better Wallet Balance Display: Updated token balances with proper decimal divisions, showing correct human-readable amounts. Correct token names for native blockchain currencies (e.g., ETH, MATIC).

Authentication

  • Nebula Auth Method: Developer can delegate scoped account access, improving security while maintaining functionality.
  • Smart Account Validator: Smart contract wallets (using ERC-1271 and ERC-6492) can now authenticate with Nebula Auth.
Greg

We just released one of our biggest updates yet to the Universal Bridge API. These changes will be coming soon to the SDK and UI components.

The new response schema includes a steps field, which gives you all the info you need to build a comprehensive bridge and swap UI. This includes token metadata, price, expected execution time, input and output amounts, and the transactions to be executed.

A buy, sell, or transfer prepared quote will now look something like this:

{
"data": {
"id": "0x11cb09cf545d9c1c1cc12aa20aaee180a59336ec72701b148f452734c50f1bbf",
"originAmount": "17055594260",
"destinationAmount": "10000001000001000005",
"blockNumber": "22325874",
"timestamp": 1745340923953,
"estimatedExecutionTimeMs": 22000,
"intent": {
"originChainId": 1,
"originTokenAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"destinationChainId": 8453,
"destinationTokenAddress": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"amount": "10000001000001000005",
"sender": "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
"receiver": "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709"
},
"steps": [
{
"originToken": {
"chainId": 1,
"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"symbol": "USDC",
"name": "USD Coin",
"decimals": 6,
"priceUsd": 0.999949,
"iconUri": "https://coin-images.coingecko.com/coins/images/6319/large/usdc.png?1696506694"
},
"destinationToken": {
"chainId": 8453,
"address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"symbol": "ETH",
"name": "Ether",
"decimals": 18,
"priceUsd": 1695.537726,
"iconUri": "https://assets.relay.link/icons/1/light.png"
},
"transactions": [
{
"chainId": 1,
"to": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"data": "0x095ea7b3000000000000000000000000f8ab2dbe6c43bf1a856471182290f91d621ba76d00000000000000000000000000000000000000000000000000000003f897b714",
"type": "eip1559",
"id": "0xe984ce73defcb35a2decb07b1cbadb57bea0e9bd4c3d919f286988daae5e98a8",
"action": "approval"
},
{
"type": "eip1559",
"to": "0xF8Ab2dBE6c43bf1a856471182290f91D621Ba76d",
"from": "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
"value": "0",
"data": "0x...",
"chainId": 1,
"action": "buy",
"id": "0x3b575d76157c50c94c61f0e1265dee784d00d2ad7502f1c6a6dba938e270b196",
"spender": "0xfCEF2Fe72413b65d3F393d278A714caD87512bcd"
}
],
"originAmount": "17055594260",
"destinationAmount": "10000001000001000005",
"estimatedExecutionTimeMs": 22000
}
]
}
}

Onramp quotes will now have the following schema:

{
"data": {
"id": "5a066908-82da-4d31-8dea-99c45f72e98b",
"link": "https://pay.coinbase.com/buy/select-asset?appId=41cbb2fb-8b35-45b9-949b-9672bc8edb78&addresses=%7B%220x2247d5d238d0f9d37184d8332aE0289d1aD9991b%22%3A%5B%22unichain%22%5D%7D&assets=%5B%22USDC%22%5D&defaultAsset=USDC&defaultNetwork=unichain&presetCryptoAmount=1716.321932&fiatCurrency=USD&partnerUserId=7d789de0-b4e0-4aac-84b4-5e13b11c896d",
"destinationAmount": "1000000100000010000",
"timestamp": 1745341089555,
"expiration": 1745344689547,
"intent": {
"chainId": 324,
"tokenAddress": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"amount": "1000000100000010000",
"receiver": "0x2247d5d238d0f9d37184d8332aE0289d1aD9991b",
"onramp": "coinbase",
"currency": "USD",
"maxSteps": 2,
"excludeChainIds": []
},
"steps": [
{
"originToken": {
"chainId": 130,
"address": "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
"symbol": "USDC",
"name": "USDCoin",
"decimals": 6,
"priceUsd": 0.999949,
"iconUri": "https://ethereum-optimism.github.io/data/USDC/logo.png"
},
"destinationToken": {
"chainId": 324,
"address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
"symbol": "ETH",
"name": "Ether",
"decimals": 18,
"priceUsd": 1691.447,
"iconUri": "https://assets.relay.link/icons/1/light.png"
},
"transactions": [
{
"chainId": 130,
"to": "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
"data": "0x095ea7b3000000000000000000000000f8ab2dbe6c43bf1a856471182290f91d621ba76d00000000000000000000000000000000000000000000000000000000664cfe8c",
"type": "eip1559",
"id": "0xb1ec1d50e1ef52ebb5fab91103f05605e9d24fb8ff26c4e5ef728e41ff82b788",
"action": "approval"
},
{
"type": "eip1559",
"to": "0xF8Ab2dBE6c43bf1a856471182290f91D621Ba76d",
"from": "0x2247d5d238d0f9d37184d8332aE0289d1aD9991b",
"value": "0",
"data": "0x...",
"chainId": 130,
"action": "buy",
"id": "0x1c66f9e7aefee5ffcc9b22595d07c3eedfa89deaec189707f73272f8e52d1d7b",
"spender": "0x078D782b760474a361dDA0AF3839290b0EF57AD6"
}
],
"originAmount": "1716321932",
"destinationAmount": "1000000100000010000",
"estimatedExecutionTimeMs": 2000
}
],
"currency": "USD",
"currencyAmount": 1716.321932
}
}

The steps are to be completed after the use has done the initial onramp.

You can find all this and more in our API reference docs.

Features

  • steps parameter for all quotes with prepared transactions and estimates
  • Faster approximate quote responses
  • Onramping with post-onramp cross-chain swaps
  • Fiat quote included in onramp responses

Bug Fixes

  • Removed ZK chains from intermediate steps, due to inconsistent addresses when using smart wallets
Yash Kumar

We have added CLI and SDK support for Stylus contracts.

This allows developers to use thirdweb CLI to create, publish, and deploy their contracts written with Stylus. The deployed contracts can be used via thirdweb dashboard or SDK.

Prerequisites:

You can also use the Stylus quickstart guide for reference: https://docs.arbitrum.io/stylus/quickstart

Here's how to use this feature:

Setup a starter repo (can be skipped if you already have a Stylus project)

npx thirdweb create-stylus

This will setup a project containing a template contract.

You can now publish this contract by running the publish command:

npx thirdweb publish-stylus -k <YOUR SECRET KEY>

Publishing a contract saves the contract metadata to an onchain registry, and creates a contract page from where you can deploy a specific version of this contract multiple times.

This is how it will look:

Alternatively, you can use the deploy command to do a one-time deployment:

npx thirdweb deploy-stylus -k <YOUR SECRET KEY>

After deployment, the contract will be available on thirdweb dashboard. You can interact with it via dashboard or integrate it in your app using the code snippets as shown below:

Greg

We've significantly increased the number of onramp routes available in the Universal Bridge widget. You can now onramp to chains like Mantle, Unichain, Lens, Treasure, and more. No SDK upgrade necessary. Try it out on the bridge page here.

0:00
/0:41
Arsenii

We’ve fixed the issues with how metadata links are resolved — and introduced a new way to give you control over it.

Accurate Link Resolution

  • Fixed a bug where metadata responses sometimes included incorrectly resolved URLs.
  • Added validation logic to detect bad URIs in cached or stored metadata — and automatically re-fetches only the original source.

🧠 New: Control Over Metadata Link Resolution

  • Introduced a new resolve_metadata_links parameter (default: true) to all NFT endpoints which can return metadata.
  • When set to false, the response will return original links such as ipfs:// and ar://, instead of their resolved HTTP versions.

This gives clients full control — whether you want cleanly resolved URLs or raw metadata as authored on-chain.

Joaquim Verges

We're excited to announce a major enhancement to the thirdweb TypeScript SDK that will significantly improve the developer experience when building blockchain applications. With release 5.95.0, we've supercharged the SDK by integrating it with Insight - our in-house indexer - replacing traditional RPC calls for fetching contract state, events, balances, NFT metadata, and more.

The Power of Insight

Until now, the thirdweb SDK has relied primarily on RPC calls to fetch on-chain data. While functional, this approach sometimes faced limitations in terms of speed, reliability, and functionality. By integrating Insight directly into our SDK, we've addressed these challenges head-on, offering:

  • Significantly faster queries for contract events, balances, and NFTs
  • Enhanced reliability with reduced dependency on mutli roundtrip RPC calls
  • Cross-chain functionality that lets you query data across multiple blockchains in a single call
  • Advanced filtering capabilities for more precise data retrieval

What's New in the SDK

New capabilities in the Connect UI components

The Connect UI modal now uses Insight to give your users a full wallet experience directly in your websites:

  • Shows all ERC20 token balances
  • Show all NFTs
  • Shows past transactions of the connected wallet
0:00
/0:11

You can now view all your tokens and NFTs in the connect modal

Supercharged Existing Functions

Your favorite thirdweb functions have been turbocharged with Insight integration:

  • getContractEvents
  • getOwnedNFTs
  • getNFTs
  • getNFT

These functions now automatically leverage our indexer on supported chains, with a graceful fallback to traditional RPC calls when needed.

If you're already using those functions in your app, no changes needed on your end, you'll just get the improved functionality out of the box.

If for any reason you need to turn off that behavior, you can pass useIndexer: false to always use RPC.

New Insight Namespace

We've added a dedicated Insight namespace with powerful new functions:

  • Insight.getOwnedTokens() - Get ERC20 tokens owned by an address across multiple chains
  • Insight.getOwnedNFTs() - Get NFTs (ERC721 and ERC1155) owned by an address
  • Insight.getNFTs() - Get NFTs (ERC721 and ERC1155) for a given contract
  • Insight.getNFT() - Get NFTs metadata for a given contract and tokenId
  • Insight.getTransactions() - Get all transactions for a given wallet address
  • Insight.getContractEvents() - Query indexed events with advanced filtering options

You can import those with import { Insight } from "thirdweb"

New Standalone Package: @thirdweb-dev/insight


For developers who need direct access to our indexer API, we've released a standalone package: @thirdweb-dev/insight. This lightweight API wrapper provides:

  • Typed functions, request bodies, and responses
  • Always stays in sync with the Insight API
  • Perfect for backend applications requiring optimized blockchain data access, without the rest of the SDK

Hands-on Examples

For the existing functions, you will get the improved functionality out of the box without any changes. If you want to use the new multichain capabilities directly, here's some examples using the new Insight namespace:

Get ERC20 Tokens Across Multiple Chains

import { Insight } from "thirdweb";
const tokens = await Insight.getOwnedTokens({
client,
ownerAddress,
chains: [base, polygon, arbitrum],
});

With just a few lines of code, you can now retrieve all ERC20 tokens owned by an address across Base, Polygon, and Arbitrum networks simultaneously!

Fetch Owned NFTs

import { Insight } from "thirdweb";
const nfts = await Insight.getOwnedNFTs({
client,
ownerAddress,
chains: [sepolia],
});

Get Transaction History

import { Insight } from "thirdweb";
const transactions = await Insight.getTransactions({
client,
walletAddress,
chains: [sepolia],
});

Query Indexed Contract Events

import { Insight } from "thirdweb";
const events = await Insight.getContractEvents({
client,
chains: [sepolia],
contractAddress: "0x...",
event: transferEvent(),
decodeLogs: true,
});

Using the Standalone Insight Package

For developers who want low level access to the Insight API with type-safe functions, here's how to use the standalone @thirdweb-dev/insight package:

Configuration

import { configure } from "@thirdweb-dev/insight";
// Call this once at the startup of your application
configure({
clientId: "<YOUR_CLIENT_ID>",
});

Example Usage

import { getV1Events } from "@thirdweb-dev/insight";
const events = await getV1Events({
query: {
chain: [1, 137],
filter_address: "0x1234567890123456789012345678901234567890",
},
});

These functions will map one to one with the Insight OpenAPI spec and will stay in sync as the service changes.

Getting Started

These new features are available now in thirdweb SDK v5.95.0 and the new @thirdweb-dev/insight v1.0.0 package.

To get started:

npm install thirdweb@latest
# Or if you need the standalone package
npm install @thirdweb-dev/insight

Looking for dotnet/unity? It's already out, head over to the dotnet documentation to learn more.

What's Next?

This Insight integration is just the beginning. We're continuously working to enhance the thirdweb developer experience with more powerful indexing capabilities, additional cross-chain functionality, and deeper integration with our developer tools ecosystem.

Stay tuned for more updates, and as always, happy building!


For more detailed documentation on these new features, visit portal.thirdweb.com.

Toomas Oosalu

Insight adds more data to token price API to also return market data, historical price data and holder count in addition to the price!

Market Data

The following data is now included by default for each token:

percent_change_24h - Percentage change of the price over the last day

volume_24h_usd - Trading volume in USD over the last day

volume_change_24h - Percentage change of volume over the last day

market_cap_usd - Market cap value in USD

Holder Count

By specifying include_holders=true query param the number of on-chain holders of the token will also be returned

Historical Price Data

By including include_historical_prices=true query param, the response will contain a list of token prices per hour over the last 30 days.


Here is an example response for USDC on Ethereum

{
"data": [
{
"chain_id": 1,
"address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
"symbol": "USDC",
"price_usd": 0.9998078912327243,
"price_usd_cents": 100,
"percent_change_24h": -0.02612099,
"market_cap_usd": 60411059379,
"volume_24h_usd": 10036602253,
"volume_change_24h": 6.5387,
"historical_prices": [
{
"date": "2025-03-18 11:00:00",
"price_usd": 0.9998556959666844,
"price_usd_cents": 100
},
{
"date": "2025-03-18 12:00:00",
"price_usd": 0.9998533259452913,
"price_usd_cents": 100
},
{
"date": "2025-03-18 13:00:00",
"price_usd": 0.9998012400259259,
"price_usd_cents": 100
},
.... and so on over the next 30 days...
],
"holders": 2994360
}
]
}

Try it out in our playground


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

Joaquim Verges

We're constantly working to improve the developer and administrative experience of ecosystem wallets. Today, we're excited to announce two significant enhancements to Ecosystem Wallets, designed to give you more flexibility and control:

  1. Unified User Search: Find users faster, regardless of the address you have.
  2. Better Ecosystem Analytics: You can now see how each partner brings users to your ecosytem over time
  3. Collaborative Partner Management: Empower your team to manage ecosystem partners and rules directly.

Let's dive into the details:

1. Enhanced User Search: Find Users by Signer (EOA) or Smart Account Address

Managing users within your ecosystem just got easier. When you enable Account abstraction for you ecosystem, you can now query with users based on their originating Externally Owned Account (EOA) or their deployed Smart Account address. Previously, only EOA search was allowed.

What's New:

  • You can now search for specific users within the Ecosystem Wallets dashboard using either their Signer Address (EOA) or their specific Smart Account address associated with your project.

How to Use:

const userDetails = await getUser({
client,
walletAddress: "0x...", // can be either EOA or smart account address
});

You can also use the backend API directly.

2. Better Ecosystem Analytics

You can now view how much each partner is contributing to your ecosystem over time. Previously you could only see overall stats for the ecosystem.

What's New:

  • Your ecosystem dashboard now shows connection analytics broken down by partner. So you can measure the success of each partner in your ecosystem.

How to Use:

  • Simply navigate to your ecosystem page in the dashboard, and go to the analytics tab to see the new stats.

3. Team-Based Ecosystem Partner & Rule Management

Managing the partners and rules that govern your ecosystem can now be done by anyone in your team. Previously, these configurations might have been restricted to the team owner.

What's New:

  • Authorized team members within your thirdweb project now have the ability to add new Ecosystem Partners and edit the configurations and rules for existing partners directly from the dashboard.

How to Use:

  • Team members with appropriate permissions can access the Ecosystem Partner configuration section within the thirdweb dashboard to add or modify partner details and rules. (Ensure your project's team roles are configured accordingly in the thirdweb dashboard settings).

These updates are live now in your thirdweb dashboard and SDKs.

Happy building!

Arsenii

We’ve just completed a full rollout of metadata performance upgrades across all NFT-related API routes — and started extending the same treatment to ERC20s.

What’s New?

Optimized Metadata Across All NFT Routes

Every API call involving NFT metadata now performs a single, efficient data read per request — even for multichain queries. Whether you're pulling transfers, balances, or metadata directly, things just got a whole lot faster.

🚀 Performance Gains: NFT Metadata Latency Drops by 10x+

We’ve slashed the latency for NFT metadata queries — and the numbers speak for themselves. For example, data for GET /v1/nfts/:contract_address

MetricBeforeAfter🔻 Improvement
p50103 ms5.9 ms~17× faster
p75152 ms13.4 ms~11× faster
p90243 ms54.8 ms~4.4× faster
p95327 ms99.3 ms~3.3× faster
p99464 ms192.1 ms~2.4× faster
p99.9555 ms242.3 ms~2.3× faster
Max756 ms290.2 ms~2.6× faster
  • GET /v1/nfts and GET /v1/nfts/transfers also saw solid improvements in the ~1.1× to 2.9× range, with reduced tail latencies and smoother performance across the board.
  • Not just faster — more consistent, with reduced tail latencies and fewer spikes in production.
  • These performance gains are now live for all metadata queries hitting the NFT endpoints.

🧱 ERC20 Metadata Storage Begins

We’ve started persisting ERC20 metadata as well, laying the foundation for more efficient token balance queries with rich metadata. Stay tuned — optimized joined queries are on the way.

🔄 Unified NFT Balances Endpoint

We’ve consolidated NFT balance queries under a single route:
/v1/nfts/balance/{ownerAddress}
This new endpoint works across ERC721 and ERC1155 standards, supports multichain queries out of the box, and is the one we recommend going forward.

Heads up: the old ERC721/ERC1155-specific balance endpoints are still live, but are now officially deprecated.

This makes it easier than ever to query, display, and work with NFTs and tokens at scale — with less overhead and more consistency.

Toomas Oosalu

Insight adds two new endpoints - one to lookup a token based on symbols and one to retrieve an NFT collection's metadata.

Token Lookup

Search for tokens by their symbol across 6000+ tokens.

Symbols are not unique nor strictly curated however, so be careful with how you use them!

To fetch all tokens with symbol ETH on Ethereum and B3

const lookupTokens = async (symbol: string) => {
try {
const response = await fetch(
`https://insight.thirdweb.com/v1/tokens/lookup?symbol=${symbol}&chain=1`,
{
headers: {
"x-client-id": <THIRDWEB_CLIENT_ID>,
},
},
);
const res = await response.json();
return res.data;
} catch (error) {
console.error("Error:", error);
}
};
await lookupTokens("ETH")

Try it out in our playground

Collection Metadata

Get metadata about an NFT collection.

By including a include_stats=true query param, you can also get the following statistics about a collection:

  • owner_count - Amount of distinct addresses that hold the NFTs
  • mint_count - Amount of NFT tokens that have been minted
  • token_count - Amount of distinct token IDs that currently exist
  • total_quantity - Amount of tokens that currently exist
const getCollectionMetadata = async (contractAddress: string) => {
try {
const response = await fetch(
`https://1.insight.thirdweb.com/v1/nfts/collection/${contractAddress}?include_stats=true`,
{
headers: {
"x-client-id": <THIRDWEB_CLIENT_ID>,
},
},
);
const res = await response.json();
return res.data;
} catch (error) {
console.error("Error:", error);
}
};

Try it out in our playground


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

Toomas Oosalu

We're excited to announce that thirdweb Insight has expanded its blockchain data querying capabilities to 84 chains, adding these 17 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!

Greg

We've added support for MAGIC on Treasure (61166) and GHO on Lens (232) to our Universal Bridge, bringing the total number of routes available to over 35,000. Check out the full API reference here to get started, or try it in the playground.

Arsenii

We’ve rolled out a series of performance upgrades across the board to make NFT metadata queries faster, smarter, and more reliable than ever.

What Changed?

Unified Fetching for NFT Data

  • NFT metadata, ownership info, and token data are now pulled in a single optimised query internally, reducing the number of round trips and improving latency consistency.
  • This makes NFT-related endpoints much more consistent at scale.

🧠 Smarter Metadata Handling

  • Metadata is now fetched on-demand only when needed, skipping unnecessary lookups for already known or irrelevant data.
  • We've introduced a system to automatically skip refetching metadata that’s deemed not worth roundtrips — improving efficiency without losing accuracy.

🪄 Parallel Processing & Query Optimizsation

  • Queries for metadata are now parallelised, making better use of compute resources.
  • Owner and balance aggregations are now handled more effectively, ensuring both speed and correctness in multi-owner or high-traffic collections.

🛠️ Critical Bugfix for NFT Transfers

  • Fixed a major issue where NFT transfers were duplicated across chains. Transfer data is now properly filtered per chain, ensuring clean and accurate results.
  • Transfer endpoints now properly correlated to chain identification to avoid any confusion in multichain contexts.

🔁 Same Gains for Fungible Tokens (ERC20)

All of these improvements won’t just apply to NFTs — we’re extending the same performance, consistency, and metadata logic enhancements to ERC20 tokens as well.


🔁 What's next? All of these improvements won’t just apply to NFTs — we’re extending the same performance, consistency, and metadata logic enhancements to ERC20 tokens as well.


💡 Result? lower and more predictable response times, better metadata hygiene, and fewer redundant operations — even across large multichain datasets.

Let us know what you think — or better yet, try it out and feel the speed.

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!