Changelog

Firekeeper

What's Changed

Full support for v7 Account Factories and Entrypoints has been added.

Rust static libraries have been updated, and Smart Wallet creation now includes a new advanced EntryPoint parameter.

When using our default v7 Account Factory, or a custom one based on the v7 standard, you can provide the v7 EntryPoint address to override the default v6 behavior.

Default Factories and Entrypoints

  • v6 Default Factory: 0x85e23b94e7F5E9cC1fF78BCe78cfb15B81f0DF00
  • v6 EntryPoint: 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789
  • v7 Default Factory: 0x4bE0ddfebcA9A5A4a617dee4DeCe99E7c862dceb
  • v7 EntryPoint: 0x0000000071727De22E5E9d8BAf0edAc6f37da032

Simple Example Forcing v7 Smart Wallets

Simple Example

You can find the latest release on Github.

Samina Kabir

We’ve rebuilt the thirdweb developer platform for the AI-native era. You can now build apps 80% faster with our new HTTP API, MCP server and new LLM optimized documentation. We've also re-organized the platform to be simpler and better organized.

What’s New


New all-in-one API: https://api.thirdweb.com

  • Manage user and server wallets
  • Transact gasless-ly with highly performant EIP7702 execution
  • Query any blockchain data both indexed and real time
  • Monitor all your transactions on your project dashboard
0:00
/0:15

Track all user and server transactions with advanced transaction info and debugging

Check out the full api reference.


New MCP server

The entire thirdweb platform is now available as a remote MCP server: https://api.thirdweb.com/mcp. Perfect for building agents, or directly interacting with the thirdweb platform from your favorite LLM client.

0:00
/0:50

Check out our new MCP documentation for more details.


New LLMs.txt

Inject knowledge into your coding agent by copying our new llms.txt into your project or your prompts. Example prompt:

Add a login screen that lets the user enter the email and confirm a verification code, then display their email and wallet address in the header. Docs: https://api.thirdweb.com/llms.txt

Check out our available llm optimized doc files.


New platform organization

We've organized the dashboard and documentations around our new main categories: Wallets, Transactions, Contracts, Payments, Tokens and Marketplace.

You'll see this grouping reflected all across the product for a more cohesive and predictable experience.


Getting started

  1. Create a new or use an existing project in the thirdweb dashboard
  2. Discover the new API: authenticate using your project’s secret key and start exploring the new endpoints for Wallets, Contracts, Payments, etc. See the documentation reference.
  3. Work with AI: test the MCP server in your favorite LLM client, or inject our new llms.txt and build apps in minutes

⚠️ Heads up for existing users

If you’re already using our APIs or SDKs, no action is required.

  • You can continue using your existing setup
  • Gradual adoption is supported, if desired, and you can migrate endpoint-by-endpoint if you like
  • Your current auth keys and project still work and nothing is changing on your current build.
If you use the upgraded API, all actions — whether client-side or server-side — show up in the dashboard. That means better monitoring, logs, transaction lifecycle tracking, and visibility across your app.

🧠 FAQs

Q: Will the old APIs or SDKs be deprecated?

No. SDKs and dedicated service APIs are here to stay and will continue to evolve as before towards the new product simplification without any breaking changes.

Q: How are the upgraded services priced?

Services are priced as they are currently- no changes. Requests will be charged based on usage to the underlying infrastructure. See our pricing page for more details.

Q: Will portal docs change?

Yes. We’re gradually reorganizing our portal to match the new interfaces. You will see a lot of changes coming up daily. We will still ensure users on existing services have relevant documentation available.

If you need help on finding anything please let us know.

And as always, we are here for support. Our team will be on standby for support around the upgraded API. Please join us for any feedback or questions in our community Telegram channel.

Giselle Chacon

New Feature: You can now access support directly from the thirdweb dashboard.

What’s New

  • Support Tab: A new “Support” tab is now available on the team sidebar
  • AI Agent: Get quick answers with our built-in AI support chat
  • Case Management: Create, track, and manage support cases directly from your dashboard

How It Works

  • Open a new case for the thirdweb team to review
  • View the status and history of existing cases
  • Use the AI agent for instant guidance on common issues

Next Steps

Joaquim Verges

We just enabled EOA execution for server wallets, allowing you to self fund your own server wallets, and directly executing onchain transactions from them.

How to use EOA execution

Set type: "EOA" in your executionOptions and pass your server wallet EOA address (signer).

Remember to fund the EOA with some native currency on that chain!

curl -X POST "https://engine.thirdweb.com/v1/write/contract" \
-H "Content-Type: application/json" \
-H "x-secret-key: <your-project-secret-key>" \
-d '{
"executionOptions": {
"type": "EOA",
"from": "<your-EOA-server-wallet-address>",
"chainId": "84532"
},
"params": [
{
"contractAddress": "0x...",
"method": "function mintTo(address to, uint256 amount)",
"params": ["0x...", "100"]
}
]
}'

If your EOA runs out of funds, the transactions will be paused until you send some funds to it, then all transactions will resume automatically.

Happy building! 🛠️

Joaquim Verges

We just enabled EIP7702 for server wallets, resulting in 4x faster sponsored transactions from sending to confirming when compared to ERC4337 execution.

How to use 7702 execution

Simply pass your server wallet EOA address (signer), execution will automatically default to EIP7702 execution and sponsor gas for the transaction.

curl -X POST "https://engine.thirdweb.com/v1/write/contract" \
-H "Content-Type: application/json" \
-H "x-secret-key: <your-project-secret-key>" \
-d '{
"executionOptions": {
"from": "<your-EOA-server-wallet-address>",
"chainId": "84532"
},
"params": [
{
"contractAddress": "0x...",
"method": "function mintTo(address to, uint256 amount)",
"params": ["0x...", "100"]
}
]
}'

You can also explicitly enable it by passing type: "EIP7702" in the execution options. Other execution types are "ERC4337" and "EOA".

If you pass your smart contract wallet address, by default engine will use ERC4337 execution like before, no changes needed.

Take advantage of EIP7702 for your server wallets and let us know about your experience!

Greg

We've made significant improvements to the Payments (Universal Bridge) API's performance, improving average latency from 900ms to under 300ms. You can now get quotes, routes, token prices, and more in a third of the time. Our Payments API powers advanced user-centric UIs using our Payments Widgets, try them out here.

Manan Tank

We’ve redesigned the ERC20 contract page to improve usability, shareability, and conversion. This update is live for all ERC20 contracts - including the ones you deploy from thirdweb dashboard

The Buy Token section is now placed at the top, making it easier for users to purchase tokens immediately. This also makes the page ideal for sharing with your community or end users.

The Token Price Chart has been moved further down to prioritize key actions and reduce visual clutter.

Several visual enhancements offer a cleaner, more user-friendly experience.

Examples

Checkout the updated layout for some popular tokens

Jake Loo

Breaking Change: The Nebula API now requires a paid subscription plan. Free usage is limited to essential testing purposes.

What's Changed

  • Free Tier: Limited to 1 RPS and 3 RPM (for testing only)
  • Paid Plans Required: Production usage now requires one of the following plans:
    • Starter: 1 RPS, 10 RPM
    • Growth: 5 RPS, 100 RPM
    • Scale: 10 RPS, 500 RPM
    • Pro: 30 RPS, 1500 RPM
    • Custom: Reach out!

Next Steps

  • Review your current Nebula API usage and update your integration to handle the new rate limits
  • Select an appropriate plan on your team account on the dashboard

For questions about plan selection or enterprise needs, contact the thirdweb team.

Joaquim Verges

You can now use the Transaction API with just your project secret key.

When you create a new project, we now initialize a secure Vault automatically for you which lets you create server wallets and transact immediately with just your project secret key.

curl -X POST "https://engine.thirdweb.com/v1/write/contract" \
-H "Content-Type: application/json" \
-H "x-secret-key: <your-project-secret-key>" \
-d '{
"executionOptions": {
"from": "<your-server-wallet-address>",
"chainId": "84532"
},
"params": [
{
"contractAddress": "0x...",
"method": "function mintTo(address to, uint256 amount)",
"params": ["0x...", "100"]
}
]
}'

What changed

  • Before: Performing transactions with your server wallets required BOTH a project secret key (x-secret-key) AND a vault access token (x-vault-access-token).
  • After: You can now do server wallet transactions with ONLY your project secret key

Your project secret key is now all you need to access thirdweb infrastructure and your server wallets from your backends.

If you've already created a vault for your project, nothing changes, you can continue using your vault access tokens normally.

How it works

When you create a project, we generate a secret key that only you have access to. We do not store that secret key only a hash of it. At project creation time, we now generate a Vault access token, encrypt with your project secret key, and store it.

This lets you now interact with your vault as long as you pass your secret key to the thirdweb transaction API.

At any point, you can choose to take control of your own Vault keys by revoking the Vault keys from the vault tab. This will invalidate any previous keys and generate new ones that you can store those yourself.

Happy building!

Joaquim Verges

You can now search users by email, phone, id or address in your project or ecosystem by navigating to the Users tab.

Select the search criteria, type a value and hit search. Great for quickly finding user associated addresses or emails.

Happy building!

Toomas Oosalu

The v1/tokens endpoint in Insight API now supports sorting by various attributes.

New sort_by and sort_order query parameters have been added. The following attributes are supported:

  • token_address - sort tokens alphabetically
  • token_price - sort based on the USD price of the token
  • usd_value - sort based on the USD value of the token per wallet, meaning balance multiplied by the token price
  • balance - sort based on the balance of the token for a wallet

sort_order can be either asc or desc

Try it out on our playground!


Additionally, another parameter was added, called include_without_price . This is true by default to have all tokens included, but setting it to false will remove tokens that do not have price data in the response.

...

These additions make the API better suited to be used in wallet applications to show user balances and present the data in the most useful way to the user.


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

Joaquim Verges

Version 5.105 spans accross multiple patch releases. It introduces more flexible payment options, upgrades wallet connectivity, new eip-7702 session key capabilities and delivers a range of UI and developer‑experience refinements.

  • Payment widgets
    • New currency prop in payment widgets to control what currency to display (USD, EUR, JPY, etc)
    • New paymentMethods prop ("crypto" / "card") to control available methods
    • Optional showThirdwebBranding flag to hide the badge
    • Show all wallet tokens in payment flow, including low balance ones
    • Optimised token‑fetch logic and better large‑number handling
    • “Unsupported Token” fallback screen and sponsored‑gas handling
    • feePayer is now respected for choosing which party will pay the transfer fees (seller or user)
  • Wallet connectivity
    Migrated connection UI widgets and core functions to WalletConnect Universal Provider for faster, multi‑chain sessions on both web and react native platforms.
  • Session keys & admin safeguards
    Added createSessionKey extension for EIP‑7702 In‑App Wallets. This comes with fine grained session key permissions, from function selector to specific argument value to time bound and recurrent permissions. You can now for example add a session key which allows to spend 10 USDC per month.
  • Wallet & chain coverage
    • Frame Wallet added
    • Wallet definitions refreshed
    • Trex Testnet, Somnia Testnet and other core chains registered
  • Type & API updates
    • purchaseData now strictly typed
    • Upgraded to Engine v3 APIs
  • On‑ramp webhook parsing
    Universal Bridge can now parse on‑ramp webhooks for strongly typed webhook payloads.
  • PayEmbed deprecated
    Existing flows should migrate to newer widgets: BuyWidget, CheckoutWidget and TransactionWidget.
Toomas Oosalu

Insight API now supports two new features for NFT and token balance endpoints.

Contract Filters

v1/tokens and v1/nfts endpoints now supports filtering the balances of a wallet by contract addresses.

For tokens, you can add a token_address query filter.

For NFTs, you can use contract_address in the query params.

Both endpoints support multiple contract filters - e.g. ?contract_address=0x...&contract_address=0x...

Cross-Wallet Balances

v1/tokens and v1/nfts endpoints also added support for multiple owner_address query filters so you can get the balances of multiple wallets in the same query!

For example, to get the token balances of both vitalik.eth and barmstrong.eth you can make the following call to Insight

curl 'https://insight.thirdweb.com/v1/tokens?chain=1&metadata=true&include_native=true&limit=5&owner_address=vitalik.eth&owner_address=barmstrong.eth'

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

Firekeeper

EIP-7702 execution mode for In-App and Ecosystem Wallets is now available on Berachain Mainnet & Berachain Bepolia!

Berachain: RPC and Chain Settings
Use the best Berachain RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.
Berachain Bepolia: RPC and Chain Settings
Use the best Berachain Bepolia RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.

These are the chains we now support, if you'd like us to support more, reach out to support!

Mainnets Supported

  • Ethereum (Chain ID: 1)
  • Gnosis (Chain ID: 100)
  • BNB Smart Chain (BSC) (Chain ID: 56)
  • Optimism (Chain ID: 10)
  • Base (Chain ID: 8453)
  • Ink (Chain ID: 57073)
  • Unichain (Chain ID: 130)
  • Zora (Chain ID: 7777777)
  • Soneium (Chain ID: 1868)
  • Mode (Chain ID: 34443)
  • Scroll (Chain ID: 534352)
  • Arbitrum (Chain ID: 42161)
  • Berachain (Chain ID: 80094)

🧪 Testnets Supported

  • Sepolia (Ethereum) (Chain ID: 11155111)
  • Gnosis Chiado (Chain ID: 10200)
  • BSC Testnet (Chain ID: 97)
  • Optimism Sepolia (Chain ID: 11155420)
  • Base Sepolia (Chain ID: 84532)
  • Ink Sepolia (Chain ID: 763373)
  • Unichain Sepolia (Chain ID: 1301)
  • Zora Sepolia (Chain ID: 999999999)
  • Soneium Minato (Chain ID: 1946)
  • Mode Sepolia (Chain ID: 919)
  • Scroll Sepolia (Chain ID: 534351)
  • Arbitrum Sepolia (Chain ID: 421614)
  • Berachain Bepolia (Chain ID: 80069)
Prithvish Baidya

Engine Cloud exits beta with a complete architectural overhaul powered by our new Rust-based Engine Core. This update introduces simplified APIs, comprehensive transaction monitoring, and significant performance improvements.

🚀 What's New

Rust-Based Engine Core

Engine Cloud is now built on Engine Core, our new open-source Rust-based blockchain transaction infrastructure. The Engine Core repository is now public.

Key improvements include:

  • Sub-second API response times (< 40ms server latency for transactions, < 10ms for status)
  • Horizontal scaling through Redis-backed job queues with configurable worker pools
  • Memory safety and zero-cost abstractions from Rust
  • Improved nonce management and transaction batching
  • Enhanced error handling with detailed context

Changed Signing API

Signature endpoints now use a new signingOptions parameter that replaces the previous executionOptions structure across all signature routes.

Before:

{
"executionOptions": {
"from": "0x...",
"chainId": 137
}
}

After:

{
"signingOptions": {
"type": "eoa",
"from": "0x...",
"chainId": 137
}
}

ERC-4337 Smart Accounts support intelligent defaults with minimal configuration:

{
"signingOptions": {
"type": "ERC4337",
"signerAddress": "0x...",
"chainId": 137,
"entrypointVersion": "v0.7"
// Optional: smartAccountAddress, accountSalt, entrypointAddress, factoryAddress
}
}

When using thirdweb's default account factory, specifying entrypointVersion automatically configures the appropriate entrypoint and factory addresses:

  • v0.6: 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789 (entrypoint), 0x85e23b94e7F5E9cC1fF78BCe78cfb15B81f0DF00 (factory)
  • v0.7: 0x0576a174D229E3cFA37253523E645A78A0C91B57 (entrypoint), 0x4bE0ddfebcA9A5A4a617dee4DeCe99E7c862dceb (factory)

The system automatically infers missing values when not explicitly provided, supporting both v0.6 and v0.7 standards.

Cleaner Response Format

Response handling is now more intuitive for single fallible operations like signMessage:

Before:

{
"result": {
"results": [
{"success": true, "data": "0x..."},
{"success": false, "error": "Invalid signature"}
]
}
}

After:

{
"result": [
{"result": "0x..."},
{"error": "Invalid signature"}
]
}

Activity Logs System

The new Activity Logs system provides visibility into transaction lifecycle and Engine operations:

  • Real-time status tracking from submission to confirmation
  • Detailed error context for failed transactions
  • Performance metrics including gas usage and timing
  • Debug information for troubleshooting

Access via dashboard or API:

GET /transactions/activity-logs?transactionId={queueId}

🔄 Migration Guide

TypeScript SDK Users

No breaking changes. Existing ServerWallet implementations continue working—simply upgrade your SDK version:

npm install thirdweb@5.105.2
const serverWallet = Engine.serverWallet({
address: "0x...", // your wallet address
chain: sepolia, // or your target chain
client: thirdwebClient,
vaultAccessToken: "your_vault_token",
});
// All existing methods work identically
const result = await serverWallet.sendTransaction(tx);

Direct API Users

Update signature endpoints to use the new signingOptions parameter. Most use cases only require changing the parameter name while keeping the same values.

Getting Started

Engine Cloud is now generally available:

  1. Create a thirdweb project
  2. Complete Transactions API onboarding to create server wallets and vault access tokens
  3. Start making API calls!

Engine Documentation → | API Reference →

Firekeeper

What's Changed

  • Various improvements and fixes related to session resuming; OAuth, Email and Phone login options should automatically resume much more often, with memory optimizations as well. In practice, this means that after creating your wallet, the IsConnected node will return true much more often, allowing you to skip the user action that typically is required.

Github Release

Firekeeper

What's Changed

  • Enhanced advanced session key management for compatible wallets, including creation of session keys with granular permissions and policies.
  • Added ability to check signer permissions, retrieve session expiration, and inspect session and policy details for signers.
  • Expanded data models to represent session states and permission limits for improved session management visibility.
  • Enhanced in-code examples and comments to illustrate session key workflows and permission management.

Links

.NET Release | NuGet Release | Unity Release

Documentation | Support

Firekeeper

EIP-7702 execution mode for In-App and Ecosystem Wallets is now available on Arbitrum Mainnet!

Arbitrum One: RPC and Chain Settings
Use the best Arbitrum One RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

These are the chains we now support, if you'd like us to support more, reach out to support!

Mainnets Supported

  • Ethereum (Chain ID: 1)
  • Gnosis (Chain ID: 100)
  • BNB Smart Chain (BSC) (Chain ID: 56)
  • Optimism (Chain ID: 10)
  • Base (Chain ID: 8453)
  • Ink (Chain ID: 57073)
  • Unichain (Chain ID: 130)
  • Zora (Chain ID: 7777777)
  • Soneium (Chain ID: 1868)
  • Mode (Chain ID: 34443)
  • Scroll (Chain ID: 534352)
  • Arbitrum (Chain ID: 42161)

🧪 Testnets Supported

  • Sepolia (Ethereum) (Chain ID: 11155111)
  • Gnosis Chiado (Chain ID: 10200)
  • BSC Testnet (Chain ID: 97)
  • Optimism Sepolia (Chain ID: 11155420)
  • Base Sepolia (Chain ID: 84532)
  • Ink Sepolia (Chain ID: 763373)
  • Unichain Sepolia (Chain ID: 1301)
  • Zora Sepolia (Chain ID: 999999999)
  • Soneium Minato (Chain ID: 1946)
  • Mode Sepolia (Chain ID: 919)
  • Scroll Sepolia (Chain ID: 534351)
  • Arbitrum Sepolia (Chain ID: 421614)
Firekeeper

Building on the EIP-7702 Account Abstraction and transaction sponsorship introduced in .NET v2.21.0 and Unity v5.21.0, this release extends Session Key functionality to EIP-7702 Smart EOAs. Session Keys enable granular permission delegation to external wallets for executing transactions on your behalf.

Key Features

  • Permission Delegation: Grant time-limited access to external wallets
  • Granular Controls: Define precise execution permissions per session
  • Smart EOA Integration: Now available for EIP-7702-powered In-App Wallets, inspired by and improved from Smart Wallet session keys
  • Backend Flexibility: Delegate transaction execution to external systems while maintaining control

Usage Example

Create session keys with either full permissions or custom policies:

// Grant full permissions for 24 hours
var sessionKeyReceipt = await smartEoa.CreateSessionKey(
chainId: chain,
signerAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
durationInSeconds: 86400,
grantFullPermissions: true
);
// Grant custom permissions
var sessionKeyReceipt = await smartEoa.CreateSessionKey(
chainId: chain,
signerAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
durationInSeconds: 86400,
grantFullPermissions: false,
callPolicies: new List<CallSpec>(), // Contract interaction rules
transferPolicies: new List<TransferSpec>() // Value transfer rules
);

Implementation Workflow

const int chain = 11155111; // 7702-compatible chain
// Initialize EIP-7702 wallet
var smartEoa = await InAppWallet.Create(
client,
authProvider: AuthProvider.Guest,
executionMode: ExecutionMode.EIP7702Sponsored
);
// Authenticate and upgrade EOA
if (!await smartEoa.IsConnected())
{
await smartEoa.LoginWithGuest(defaultSessionIdOverride: Guid.NewGuid().ToString());
}
// Execute upgrade transaction (optional)
var receipt = await smartEoa.Transfer(
chainId: chain,
toAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
weiAmount: 0
);
// Verify account delegation (optional)
var isDelegated = await Utils.IsDelegatedAccount(client, chain, await smartEoa.GetAddress());
// Create session key
var sessionKeyReceipt = await smartEoa.CreateSessionKey(
chainId: chain,
signerAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
durationInSeconds: 86400,
grantFullPermissions: true
);

Practical Applications

Once created, these session keys can be used to:

  • Delegate transactions to backend services while maintaining security boundaries
  • Enable temporary access for third-party services
  • Create specialized roles with limited permissions
  • Automate workflows without exposing primary wallet credentials

The session key mechanism opens up numerous possibilities for secure, permissioned delegation patterns while maintaining full control over your assets and contracts.

Links

.NET Release | NuGet Release | Unity Release

Documentation | Support

Toomas Oosalu

We've made some exciting improvements to the indexing pipeline of Insight and have managed to reduce the block lag by up to 80%!

What is block lag? - Each block included in the blockchain has a timestamp of when it was constructed. Block lag, in the case of Insight, shows the difference between the block timestamp and when it is queryable via the Insight API.

For example, on Base we were able to the block lag from around 18 seconds on average to around 5 seconds on average.

On Donatuz, we were able to reduce the block lag from an average of 15 seconds to under 2 seconds consistently!

These are just a few examples, but we have applied these optimizations to all the chains Insight supports and we will be continuing work on improving Insight all around.


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

Toomas Oosalu

Insight token transfers and NFT transfers endpoints have gotten a few updates.

Block Timestamp Filter

You can now filter transfers by the block timestamp, similarly to the previously available block number filter. The following query parameters are now available:

  • block_timestamp_from - to query transfers made starting from this timestamp
  • block_timestamp_to - to query transfers made until this timestamp

Timestamp format is either a unix timestamp or milliseconds from the epoch.

Contract Address Filter

Another addition is the contract_address query filter, which you can use to only look at transfers for specific tokens or NFT collections.
The endpoints also accept multiple e.g ?contract_address=0x321...&contract_address=0x123...

Sort Order

By default, all transfers are sorted by in a descending order by block number and in an ascending order by the log index (position in the block).

The sort_order query param controls the direction of the block number sort, so you can list the transfers either from oldest or newest.

Token Endpoint Modifications

We've also removed a few query parameters from v1/tokens/transfers that had no effect previously. The parameters were: resolve_metadata_links , sales and the sale option from transfer_type.


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

Manan Tank

We’ve redesigned the contract pages on thirdweb.com/<chain>/<contract-address> to be cleaner, simpler, and more user-friendly — making them perfect for sharing with your community or users.

These pages no longer include contract management features like Setting permissions, Updating settings, Managing claim conditions, Minting tokens etc

Instead, they now focus on: Promoting your primary sales, Showcasing contract analytics, Displaying recent transfers etc

Here are few examples:

ERC20 Example

View example page

ERC721 Example

View example page

A Demo NFT Drop Contract Page

ERC1155 Example

View example page

A Demo Edition Drop Contract Page

Contract Management Moved to Projects

All advanced contract management tools are still available — they’ve just moved.

You can now access the full contract admin UI at following URL:
/team/<team>/<project>/contract/<chain>/<contract>

To access it

  1. Go to your Team > Project > Contracts tab
  2. Find your contract in the table
  3. Click the contract row to open its full contract management interface
Project contracts page
Contract Mangement Page

If the contract isn’t part of your project yet, you’ll need to import it first. Just click “Import Contract” in the top-right of the Contracts page and enter the contract’s address and chain.

Greg

We've released three new payments components to cover any use case your onchain app might need. Please note these components are still in beta and their interfaces are subject to change.

BuyWidget

Let users buy your token using any token and from any chain with the BuyWidget

0:00
/0:29

Example:

import { BuyWidget } from "thirdweb/react";
function App() {
return (
<BuyWidget
client={client}
chain={chain}
amount="0.01"
tokenAddress="0x..." // Optional: ERC20 Token contract address
recipient="0x..." // Optional: recipient address
theme="light" // Optional: "light" or "dark"
/>
);
}

CheckoutWidget

A drop-in checkout experience for digital and physical assets.

0:00
/0:32

Example:

import { CheckoutWidget } from "thirdweb/react";
function App() {
return (
<CheckoutWidget
client={client}
chain={defineChain(42161)}
amount={0.0002}
seller="0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709"
/>
);
}

TransactionWidget

A UI for any onchain transaction, paid for with funds from any chain.

0:00
/0:24

Example:

import { TransactionWidget } from "thirdweb/react";
import { prepareContractCall } from "thirdweb";
function App() {
const transaction = prepareContractCall({
contract: myContract,
method: "transfer",
params: [recipientAddress, amount],
});
return (
<TransactionWidget
client={client}
transaction={transaction}
onSuccess={(result) =>
console.log("Transaction successful:", result)
}
onError={(error) => console.error("Transaction failed:", error)}
theme="light" // Optional: "light" or "dark"
/>
);
}
Cillian Berragan

We're excited to announce Nebula v0.1.0, our most comprehensive update yet! This release transforms Nebula into a universal DeFi protocol expert with the ability to execute any contract function across all EVM chains. Whether you're interacting with Uniswap, Aave, or any custom protocol, Nebula now has the knowledge and execution capabilities to handle it all.

Live now at nebula.thirdweb.com!

🚀 Major Features

Universal Protocol Knowledge Base

Nebula now comes equipped with comprehensive knowledge of 50+ major DeFi protocols across all EVM chains. From household names like Uniswap, Aave, and Curve to specialized protocols like Lido, MakerDAO, and Compound - Nebula understands them all.

Our new intelligent research system automatically discovers new protocols, analyzes their contracts, and generates up-to-date documentation for Nebula, to be added periodically. As the DeFi ecosystem evolves, Nebula evolves with it.

Execute ANY Contract Function

Our new enhanced agentic approach now supports arbitrary contract execution with sophisticated parameter handling. Whether you're:

  • Swapping tokens on a DEX
  • Providing liquidity to a pool
  • Staking in a yield farm
  • Querying live APY

Nebula can prepare and execute any transaction across any chain.

Lightning-Fast Protocol Queries

Nebula is now provided with instant access to cached protocol data, contract addresses, and deployment details. No more waiting for on-chain lookups - Nebula already knows where everything is deployed and how it works.

🎯 Enhanced Capabilities

Automated Documentation Pipeline

Behind the scenes, Nebula now automatically generates comprehensive protocol documentation by combining on-chain analysis with web research. This means every interaction is backed by the latest, most accurate information about how protocols actually work.

Smarter Function Calling

We've significantly improved Nebula's function calling capabilities with better parameter validation and error handling. The agent now makes fewer mistakes and provides clearer feedback when things go wrong.

Performance Optimizations

  • Parallel Image Generation: Visual content now generates concurrently for faster responses
  • Specialized Transaction Tools: Split transaction and event aggregation into focused tools for better accuracy
  • Enhanced Memory Management: Improved context handling for complex multi-step protocol interactions

💡 Example: Multi-Protocol DeFi Strategy

Here's how the new capabilities work together. Ask Nebula:

"Provide liquidity to the USDC/ETH pool on Uniswap V3"

Nebula will:

  1. Research the current pool parameters and optimal price ranges
  2. Prepare any required approvals
  3. Prepare the Uniswap V3 liquidity provision transaction

Once successfully executed, Nebula can collect fees, monitor performance, withdraw liquidity or execute any other on-chain interaction.

All of this happens seamlessly across protocols, with Nebula understanding the nuances of each platform.

🔧 General Improvements

  • Advanced Web Search: Better protocol-specific query handling and result filtering, for information that isn't already cached by Nebula
  • Cross-Chain Compatibility: Enhanced support for protocol interactions across different EVM chains
  • Improved Error Handling: More informative error messages and recovery suggestions
  • Better Transaction Aggregation: More accurate grouping and analysis of related transactions

What's Next?

With this foundation of universal protocol knowledge and arbitrary contract execution, we're laying the groundwork for even more powerful DeFi automation and strategy execution. Stay tuned for exciting developments in the coming releases!


Ready to explore the full potential of DeFi with Nebula v0.1.0? Try asking about your favorite protocol - chances are, Nebula already knows all about it.

Arsenii

Until now, token prices in Insight were only available through dedicated /price endpoints — useful, but disconnected from the broader token experience.

Starting today, latest price data is embedded directly into all routes that can return fungible token metadata — including /v1/tokens/balances & v1/tokens/transfers with metadata flag set to true . That means you’ll now see up-to-date pricing info (like price_usd, percent_change_24h, volume_24h_usd, and more) inline with your token balances and other metadata-rich responses.

This change makes it drastically easier to surface value and context in a single call — whether you're showing wallet assets, building dashboards, or triggering logic based on price.

💡
Heads up if you're still using /tokens/erc20 endpoints
That family of routes is being deprecated in favour of the new generalised /tokens API. As part of this transition, those older endpoints will not receive price data enrichment — so if you're relying on token value context, now's the time to switch. /tokens is faster, more complete, and future-proof.

A few more notes:

  • This works for both ERC-20 and native tokens.
  • Currently this is powered by the offchain aggregated price feeds, but we'll work expending the strategies further.
  • Some niche tokens might not have price data (yet) — but future updates will improve coverage and enable better filtering of spammy or scammy assets based on this info.

Price data just got a lot more accessible — and this is only the beginning!


Let us know what you think!
We're always looking to improve how we serve token data — if you're using this in your app, tooling, or analytics pipeline and have thoughts, feature requests, or sharp criticism: we want to hear it. Just drop us a line in Discord or open a discussion on GitHub.

Arsenii

Users can now track fungible and non-fungible token transfers more reliably — even when the same event signature (like Transfer) is used across multiple token standards.

What’s New

  • 🔄 Multi-ABI Decoding: Webhooks now support decoding the same event signature using multiple ABIs. This is especially useful for events like Transfer that appear in both ERC-20 and ERC-721 contracts with different parameter structures.
  • 💥 Fallback Decoding: If the first ABI fails to decode the event, we now try all provided ABIs until one succeeds — making decoding more robust.
  • 🧪 Better Decoding for Edge Cases: For example, events with empty data fields ("0x") are now handled gracefully, and error handling during decoding has been improved.

🧠 AI Agent-Ready: Documentation Updates

We also updated the docs to help developers integrate with AI agents or build smart event-driven systems:

  • Clearer instructions on setting up and managing webhooks via the Insight API
  • New examples of multi-ABI event filters, including how to handle both ERC-20 and ERC-721 Transfer events
  • Payload structure explained in more depth for downstream agent consumption

Don't forget to check the docs here!

Why It Matters

Many token standards reuse the same event signature hash (Transfer(address,address,uint256)), but the meaning and structure can differ. This update makes sure your webhook will correctly decode whichever version it encounters.

📌 Note: This feature is currently available via API only — improved UI/UX support for creating and managing multi-ABI filters is on the roadmap!


Let us know if you need help setting up multi-ABI filters for your use case — or if there’s another event format we should support next.

Firekeeper

We've integrated EIP-1271 and EIP-6492 Smart Wallet signing into the UE SDK so you can verify auth seamlessly from your backend without having to deploy your smart wallets.

No changes to your code are required, simply upgrade to the latest SDK, and your signatures will now match what most authentication systems expect from smart wallets.

This is now at parity with our other SDKs (TS, React, .NET, Unity, etc.)

Github Release | Fab Marketplace
2.1.1 will be available on Fab around 6/14/2025

Nischit Pradhan

We’re thrilled to announce a powerful new addition to our RPC toolkit: native WebSocket support for Plume Mainnet (chain ID 98866) and Testnet (chain ID 98867). Now you can subscribe to live block events and react instantly as new blocks are produced—no polling required

What’s New

  • WebSocket Endpoints
    • Mainnet:
      wss://98866.rpc.thirdweb.com/ws/<client_id>
    • Testnet
      wss://98867.rpc.thirdweb.com/ws/<client_id>
  • Real-Time Block Events
    Subscribe once and receive a continuous stream of block headers and payloads as they’re finalized on-chain.

Why You’ll Love It

  1. Instant Data
    No more waiting for HTTP responses—get block notifications the moment they happen.
  2. Lower Latency
    Maintain a persistent socket connection instead of hammering REST endpoints.
  3. Scalability
    Stream to multiple clients or services without spinning up extra request handlers.

Getting Started

  1. Generate or retrieve your <client_id> from your Thirdweb dashboard.
  2. Connect via your favorite WebSocket library:
import WebSocket from "ws";
const chainId = "98866"; // or "98867" for Testnet
const clientId = "<your_client_id>";
const wsUrl = `wss://${chainId}.rpc.thirdweb.com/ws/${clientId}`;
const ws = new WebSocket(wsUrl);
ws.on("open", () => {
console.log("Connected to Plume WebSocket!");
// Subscribe to new block events
ws.send(
JSON.stringify({
id: 1,
jsonrpc: "2.0",
method: "eth_subscribe",
params: ["newHeads"],
}),
);
});
ws.on("message", (data) => {
const event = JSON.parse(data);
console.log("New block received:", event);
});
  1. Handle Events
    Every newHeads message includes block number, hash, timestamp, and parent hash—ready for indexing, alerts, or analytics.

What’s Next

  • More Chains Coming Soon!
    We’re actively working on extending WebSocket support across additional networks. Stay tuned for announcements!
Phillip Ho

You can now create new teams from the thirdweb dashboard. This feature allows you to create multiple teams to separate team members and projects effectively.

Why use teams? Use different teams to organize separate apps or clients, each with their own assets, team members, usage analytics, and billing. Creating teams is free, and each team has its own subscriptions and team-specific limits.

Create and manage your teams

Visit the My Account page or use the team selector in the top navigation, then select "Create Team".

Switch between teams: Use the team selector to move between your teams.

Transfer a team: Simply add another owner to the team, and remove the original owner.

Example: Owner A owns team A but wants to transfer it to owner B. After owner A invites owner B to the team, owner B can remove owner A.

Delete a team: No longer need a team? Delete it from the Settings > General page.

Manage team members

Manage who can view and update your thirdweb resources by adding team members from the Settings > Members page.

Visit the Pricing page to learn more about plans that include multiple seats.

Toomas Oosalu

Insight adds support for filtering NFT transfers by type.

On the v1/nfts/transfers endpoint you can specify a transfer_type query parameter and choose to filter transfer, sale, mint or burn transfers.

transfer - Any transfer without additional sale data

sale - A transfer that has additional sale data* (Seaport protocol supported)

mint - A transfer from a zero address

burn - A transfer to a zero address

* Example sale data:

"transaction_hash": "0x6bb2c31fd42a504b375c94441693effced0c1ff41b4e8d3d8396eeed9cd55bb8",
"items_sold": [
{
"token_address": "0x413530a7beb9ff6c44e9e6c9001c93b785420c32",
"token_id": "1881",
"amount": "1",
"from_address": "0x055e4e77cbc70c59bef7f42c5603a7d77a82ca0c",
"token_type": "erc721"
}
],
"payment": [
{
"token_address": "0x0000000000000000000000000000000000000000",
"token_id": "0",
"amount": "6965000000000000",
"token_type": "",
"to_address": "0x055e4e77cbc70c59bef7f42c5603a7d77a82ca0c"
},
{
"token_address": "0x0000000000000000000000000000000000000000",
"token_id": "0",
"amount": "35000000000000",
"token_type": "",
"to_address": "0x0000a26b00c1f0df003000390027140000faa719"
}
],
"marketplace_address": "0x0000000000000068f116a894984e2db1123eb395",
"marketplace_name": "opensea"

Try it out on our playground.


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

Cillian Berragan

This release introduces significant improvements to Nebula's agent capabilities, adding fiat onramping through Universal Bridge, new NFT collection tools, and aggregated transaction and events data. Improvements have been made to Nebula’s memory handling, leading to faster responses in some cases and helping us prepare for our next major release. Additionally, we fixed a major bug that caused Nebula to respond with "No response received, please try again" in long-running queries.

Nebula v0.0.17 is live now!

Features

New Tools

  • Added an onramping tool for fiat-to-crypto transactions using thirdweb Universal Bridge
  • Improved token swap preparation for better cross-chain support and tool-calling accuracy
  • Expanded the capabilities of transaction and event aggregation

NFT Statistics and Aggregations

  • Nebula can now retrieve on-chain NFT collection statistics
  • Added NFT token retrieval for token-specific data like URI metadata
  • Enhanced transaction and event aggregation for significantly improved accuracy

Improved On-Chain Function Calling

  • Function calling has been significantly improved
  • Nebula now understands more complex contract functions and executes them accurately

Enhanced Memory and Context Management

  • Nebula now tracks deployed and referenced contracts, preserving them in session memory
  • Improved agent autonomy through better tool chaining and context retention

Aggregations are an exciting addition to Nebula's capabilities, enabling complex queries such as:

User: Find the top 5 contracts on Base in the past hour by transaction count

Nebula: Here are the top 5 contracts on Base by transaction count in the past hour (from 2025-06-05 11:15:19 UTC to now):
  1. 0xfe16e9fcc577cb9b19319f6c97d915d58545fd7f — Name: UnknownContract, Transactions: 18,324
  2. 0x00f79a40ffa54316059614c280750756412a5fc9 — Name: UnknownContract, Transactions: 14,138
  3. 0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24 — Name: UniswapV2Router02, Transactions: 14,021
  4. 0x1307b5f4f528519b3ad44c98cdf4e156686c6f63 — Name: UnknownContract, Transactions: 12,413
  5. 0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad — Name: UniversalRouter, Transactions: 12,167

General Improvements

Agent Framework Updates

  • Updated agent framework version for improved performance
  • Refined prompts for more accurate tool calling
  • Improved reasoning steps and decision-making

Connection and Stability

  • Better handling of connection timeouts to prevent "No response received" errors

Contract and Transaction Handling

  • Improved contract deployment tools with enhanced flexibility
  • Better address checksumming and output type validation
  • Enhanced transaction preparation with native token support
  • Fixed tools to properly handle base units and native tokens

Bug Fixes

  • Fixed an issue where parts of responses were cut off
  • Resolved duplicate answers in agent responses
  • Improved contract function parameter validation
  • Fixed multiple type-related issues across tools
  • Improved parameter validation for contract deployments

This release marks a significant step forward in Nebula's capabilities, delivering more reliable tools, smarter agents, and expanded financial integrations for building full-featured blockchain applications.

Samina Kabir

You can now set up webhooks directly in your dashboard to track blockchain activity in real-time—no more polling, no more missing important events.

Webhooks allow you to:

  • Get notified when specific events happen on-chain (like NFT mints, transfers, or contract calls) or any contract function you specify
  • Automate downstream processes like updating your app, sending emails, or triggering workflows
  • Stay in sync with blockchain state—even when there are re-orgs (yup, we handle that too)

Get started with webhooks by creating a project > Webhooks > Create Webhook

Joaquim Verges

We updated our ecosystem wallet smart account options to let ecosystem owners opt in to using EIP-7702 for all their users.

New Execution Mode setting in Ecosystem dashboard

Picking EIP-7702 as the smart wallet execution mode for your ecosystem has multiple benefits:

  • your users will be able to use the same smart account features as EIP-4337 like gas sponsorship, batching and session keys
  • Smart account address will be the same address as their EOA address.
  • Execution speed will be up to 3x faster than EIP-4337 userOps.
  • No code change required

Keep in mind that this standard only works on chains that have adopted the EVM pectra update. Most popular chains support it today, with more chains adopting it every week.

We recommend trying out 7702 execution for your ecosystem wallets, just enable the setting in your dashboard and connect to your ecosystem wallets to take advantage of this new smart account standard.

Happy building! 🛠️

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.