Changelog

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!

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!

• 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

• 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

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

• 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

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

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

• 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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

© 2025 Thirdweb

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.

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

List every server wallet that already exists.

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

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

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

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

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.

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.

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

• 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

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

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

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

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

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

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

Try it out on our playground.

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!

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.

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

• 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()

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!

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.

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.

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!

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 🚀

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

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

pnpm add thirdweb@5.100.0

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

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

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

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!

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

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

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

• 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

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.

• 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

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

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

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

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.

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

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

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.

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!

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.

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.

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.

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.

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

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

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

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

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

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

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

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.

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.