Changelog

• New Social Auth Endpoint: Introduced GET /v1/auth/social for simplified OAuth authentication
  • Single-step OAuth flow with automatic redirect handling
  • Supports all 12 OAuth providers: Google, Apple, Facebook, Discord, GitHub, X, Coinbase, Farcaster, Telegram, LINE, Twitch, Steam
• Complete documentation with callback examples and JWT extraction guide

• OAuth via /auth/initiate: The OAuth method in /v1/auth/initiate is now deprecated
  • Still functional but will show deprecation warnings
  • Please migrate to the new /v1/auth/social endpoint

Before (Deprecated):

// Old OAuth initiation
POST /v1/auth/initiate
{
  "method": "oauth",
  "provider": "google", 
  "redirectUrl": "https://myapp.com/callback"
}
// Handle the rest yourself

After (Recommended):

// New simplified OAuth - just redirect user to:
GET /v1/auth/social?provider=google&redirectUrl=https://myapp.com/callback

Callback Handling:

// Extract the JWT token in your callback
const urlParams = new URLSearchParams(window.location.search);
const authResultString = urlParams.get("authResult");
const authResult = JSON.parse(authResultString!);
 
// Extract the JWT token
const token = authResult.storedToken.cookieString;
 
// Verify and use the JWT token
fetch("/v1/wallets/me", {
  headers: {
    Authorization: "Bearer " + jwtToken,
    "x-secret-key": "your-secret-key",
  },
});

• Simpler Integration: One-step OAuth flow instead of separate POST + redirecting yourself
• Better Documentation: Clear (and AI-friendly) callback handling examples and JWT extraction
• Consistent API: Follows standard OAuth redirect patterns
• Future-Proof: The new endpoint will receive ongoing support and improvements

Earlier this week we launched the ability to deploy your own token right from the dashboard, complete with a liquidity pool and developer rewards. Today, we're releasing this same capability via the thirdweb API.

• Launch your token on a decentralized exchange
• Set up a Uniswap V3 pool with a pairing and starting price of your choice
• Earn rewards automatically on every trade
• Get a token page that your community can use to purchase the token with crypto or fiat payments

fetch("https://api.thirdweb.com/v1/tokens", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-secret-key": "YOUR_SECRET_TOKEN",
  },
  body: JSON.stringify({
    chainId: 42161,
    name: "MyToken",
    symbol: "MT",
    description: "My very own token",
    imageUrl: "https://picsum.photos/200",
    from: "0xEfc38EF8C09535b25e364b6d1a7C406D3972f2A9",
    maxSupply: 1000000000,
    sale: {
      type: "pool",
      startingPrice: "100000",
      amount: 1000000,
      developerFeeBps: 10,
      currency: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    },
  }),
});

Your token becomes instantly available in the thirdweb dashboard and tradable via thirdweb Payments.

This new flow is available on Ethereum, Base, Unichain, Arbitrum, Optimism, Polygon, , BNB, Avalanche C Chain, CELO, Blast, ZKsync, Zora, WorldChain and AppChain mainnets and their respective testnets

To get started, check out the thirdweb API reference, or feed the LLMs.txt to your LLM of choice.

curl https://api.thirdweb.com/v1/tokens \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-secret-key: YOUR_SECRET_TOKEN' \
  --data '{
  "chainId": 42161,
  "name": "MyToken",
  "symbol": "MT",
  "description": "My very own token",
  "imageUrl": "https://picsum.photos/200",
  "from": "0xEfc38EF8C09535b25e364b6d1a7C406D3972f2A9",
  "maxSupply": 1000000000,
  "sale": {
    "type": "pool",
    "startingPrice": "100000",
    "amount": 1000000,
    "developerFeeBps": 10,
    "currency": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
  }
}'

Launching an ERC20 token is now faster, easier, and more rewarding. Your community can start buying, trading, and holding from day one — while you earn fees in the background!

• Launch your token on a decentralized exchange
• Set up a Uniswap V3 pool with your token
• Earn rewards automatically on every trade
• Airdrop certain supply tokens on launch
• Get a token page that your community can use to purchase the token with crypto or fiat payments. Here's an Example

When you create your token, you set the lifetime total supply. Then, simply decide how to allocate it:

Reserve a portion of tokens for airdrops to a pre-selected list of recipients. Perfect for rewarding your early supporters

Make your token instantly tradable on launch and earn revenue from every trade

• Allocate some supply to the pool.
• Pair it with ETH or any ERC20 (no upfront liquidity needed).
• Earn fees automatically (1% fee per trade — 70% goes directly to you).

Any leftover supply is automatically minted to your wallet

Each trade earns 1% fee - 70% of which is earned by your wallet. You can easily claim the rewards by going to thirdweb Dashboard > Your Team > Your Project > Tokens > Select Token > Rewards and Click “Distribute Rewards” button

This new flow is available on Ethereum, Base, Unichain, Arbitrum, Optimism, Polygon, , BNB, Avalanche C Chain, CELO, Blast, ZKsync, Zora, WorldChain and AppChain mainnets and their respective testnets

You can try out the new ERC20 token creation flow in thirdweb Dashboard > Your Team > Your Project > Tokens > Create Coin

Instant Wallet Creation - Users can now create ephemeral wallets instantly without providing email, phone, or social accounts. Perfect for demos, testing, or onboarding new users to your dApp.

// Create a guest wallet instantly
const response = await fetch(
  "https://api.thirdweb.com/v1/auth/complete",
  {
    method: "POST",
    headers: {
      "x-secret-key": "your-secret-key",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      method: "guest",
      sessionId: "optional-session-id", // Auto-generated if not provided
    }),
  },
);
 
const { walletAddress, token } = await response.json();

• Zero Friction - No user information required
• Instant Setup - Wallets created in milliseconds
• Session Support - Optional sessionId for temporary persistence
• Full Functionality - Sign messages, send transactions, interact with contracts
• Easy Migration - Users can upgrade to permanent accounts later

• Demo Applications - Let users try your dApp immediately
• Testing Environments - Quick wallet creation for integration tests
• Onboarding Flows - Reduce barriers for new users
• Temporary Sessions - Perfect for short-lived interactions

• POST /v1/auth/complete - Create guest wallet
• GET /v1/wallets/me - Get wallet info (with Bearer token)
• All existing wallet operations work with guest wallets

Ready to reduce onboarding friction? Get started with guest auth →

This guide helps you migrate from the legacy Nebula API (nebula-api.thirdweb.com/chat) to the new thirdweb AI Chat API (api.thirdweb.com/ai/chat).

• Old URL: https://nebula-api.thirdweb.com/chat
• New URL: https://api.thirdweb.com/ai/chat

fetch("<https://nebula-api.thirdweb.com/chat>", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-secret-key": "your-secret-key",
  },
  body: JSON.stringify({
    message: "Send 0.01 ETH to vitalik.eth",
    stream: false,
    session_id: "your-session-id",
    context: "{ chainIds: [1]; walletAddress: '0x123...'; }",
  }),
});

fetch("<https://api.thirdweb.com/ai/chat>", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-secret-key": "your-secret-key",
  },
  body: JSON.stringify({
    context: {
      chain_ids: [1],
      from: "0x123...",
      session_id: "your-session-id", // Optional
    },
    messages: [
      {
        role: "user",
        content: "Send 0.01 ETH to vitalik.eth",
      },
    ],
    stream: false,
  }),
});

Change your base URL from:

<https://nebula-api.thirdweb.com/chat>

to:

<https://api.thirdweb.com/ai/chat>

Convert the single message field to a messages array:

Old format:

message: "Your message here";

New format:

messages: [
  {
    role: "user",
    content: "Your message here",
  },
];

Supported roles:

• user - Messages from the user
• assistant - Messages from the AI
• system - System messages for context

Old format (string):

context: "{ chainIds: [1, 137]; walletAddress: '0x123...'; }";

New format (object):

context: {
  chain_ids: [1, 137],  
  from: "0x123...",  
  session_id: "optional-session-id"
}

• Session ID is now optional and nested within the context object
• If not provided, a new session will be created automatically
• Sessions enable conversation continuity

function migrateToNewAPI(oldRequest) {
  // Parse old context string  const contextString = oldRequest.context;  const contextData = parseContextString(contextString); // Implement this helper
  return {
    context: {
      chain_ids: contextData.chainIds,
      from: contextData.walletAddress,
      session_id: oldRequest.session_id,
    },
    messages: [
      {
        role: "user",
        content: oldRequest.message,
      },
    ],
    stream: oldRequest.stream || false,
  };
}

• Standard Chat Format: Follows industry-standard conversational AI patterns
• Better Message History: Support for multi-turn conversations with role-based messages
• Structured Context: Type-safe object format instead of string parsing
• Enhanced Session Management: More flexible session handling
• Future-Proof: Aligned with modern chat API standards

1. Update your endpoint URL
2. Transform your request payload structure
3. Test with a simple message first
4. Verify session continuity works as expected
5. Test complex scenarios with multiple messages

We’ve added an OpenAI-compatible AI Chat endpoint specialized for blockchain interactions, powered by thirdweb’s 't0' model. It can query live on-chain data, analyze transactions, prepare contract calls, swaps, and more via a single /ai/chat call.

Docs: https://portal.thirdweb.com/ai/chat
Playground: https://playground.thirdweb.com/ai/chat
API reference: https://api.thirdweb.com/reference#tag/ai/post/ai/chat

• Realtime chain data: balances, prices, metadata, transaction & contract insights.
• Prepare on-chain operations: contract writes, native/token transfers, swaps, and deployments. Generates call data & parameters.
• Actionable outputs: returns structured actions (e.g., sign_transaction) you can pass to your signing/execution flow.
• Context-aware: include wallet + chain context for targeted answers.
• OpenAI-compatible: works with standard Chat Completions clients using model: "t0".

1. Explore blockchain data — find interesting contract and tokens, analyze transactions, follow transfers, etc
2. Wallet assistant — “Send 10 USDC on Base to vitalik.eth”, "Swap 0.1 ETH to USDT on Arbitrum", etc
3. Token launcher — Create tradeable tokens with natural language, generate images for the metadata.

const res = await fetch("https://api.thirdweb.com/ai/chat", {
  method: "POST",
  headers: {
    "content-type": "application/json",
    "x-secret-key": process.env.THIRDWEB_SECRET_KEY!, // project secret
  },
  body: JSON.stringify({
    messages: [
      {
        role: "user",
        content: "Transfer 0.01 ETH to vitalik.eth on Base",
      },
    ],
    stream: false,
    context: {
      from: "0xYourWallet",
      chain_ids: [8453], // Base
    },
  }),
});
const json = await res.json();
// json.actions[0] may be { type: "sign_transaction", data: { to, value, data, chainId } }

from openai import OpenAI
 
client = OpenAI(
    base_url="https://api.thirdweb.com/ai",           # uses OpenAI-compatible interface
    api_key="YOUR_TW_SECRET_KEY",                  # maps to x-secret-key
)
 
resp = client.chat.completions.create(
    model="t0",
    messages=[{"role": "user", "content": "What's my USDC balance?"}],
    stream=False,
    extra_body={ "context": { "from": "0xYourWallet", "chain_ids": [8453] } },
)
print(resp)

{
  "message": "I've prepared a native transfer. Do you want to execute it?",
  "session_id": "123",
  "request_id": "456",
  "actions": [
    {
      "type": "sign_transaction",
      "data": { "chainId": 8453, "to": "0x...", "value": "10000000000000000", "data": "0x" },
      "source": "model"
    }
  ]
}

Docs: https://portal.thirdweb.com/ai/chat
Playground: https://playground.thirdweb.com/ai/chat
API reference: https://api.thirdweb.com/reference#tag/ai/post/ai/chat

We’ve expanded the Thirdweb API with three new endpoints that make it easier than ever to swap, send, and execute payments in just a few calls. Whether you’re moving tokens across chains, building custom checkout flows, or resuming a previously prepared payment, these new endpoints give you full control over the payment lifecycle — all with the same developer-friendly API.

Instantly swap between tokens and across chains using any thirdweb wallet via POST /v1/payments/swap. Use the exact parameter to specify whether your amount is the input (pay) or output (receive) side.

curl -sS -X POST "https://api.thirdweb.com/v1/payments/swap" \
  -H "Content-Type: application/json" \
  -H "x-secret-key: <YOUR_SECRET_KEY>" \
  -d '{
    "from": "0xYOUR_WALLET",
    "exact": "input",                 
    "tokenIn":  { "address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", "chainId": 42161, "amount": "1000000" },
    "tokenOut": { "address": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", "chainId": 42161, "minAmount": "990000" }
  }'

API Reference →

Create an end-to-end payment that can bridge and/or swap under the hood with POST /v1/payments. Perfect for P2P transfers, checkouts, and payouts when you want a single call that returns the prepared steps to execute. Supports metadata and webhooks.

curl -sS -X POST "https://api.thirdweb.com/v1/payments" \
  -H "Content-Type: application/json" \
  -H "x-secret-key: <YOUR_SECRET_KEY>" \
  -d '{
    "name": "Course",
    "description": "The complete JS course",
    "imageUrl": "https://example.com/course.png",
    "recipient": "0xMERCHANT_WALLET",
    "token": { "address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", "chainId": 42161, "amount": "1000000" }
  }'

API Reference →

Submit a previously created payment with POST /v1/payments/{id}. Use this to continue processing a payment you created earlier (for example after client-side signing/approval), while preserving the same payment ID for tracking and webhooks.

curl -sS -X POST "https://api.thirdweb.com/v1/payments/<ID>" \
  -H "Content-Type: application/json" \
  -H "x-secret-key: <YOUR_SECRET_KEY>" \
  -d '{ "from": "0xBUYER_WALLET" }'

API Reference →

We've added Stargate to our growing list of supported providers in thirdweb Payments. This unlocks a number of chains such as Fuse, Kaia, and more. This will also augment all existing routes to provide better prices (when possible).

thirdweb Payments are built with a "single input" philosophy, meaning you will only need to hold one input token to complete a payment. Stargate and other LayerZero-based bridges require fees to be paid in the native token, which normally breaks the "single input" philosophy. We've rolled Stargate's fees into the input token, allowing for even LayerZero bridges to be used with a single input token.

Try Stargate and all other payments in the HTTP API or the SDK.

The thirdweb API is your unified toolkit for building next-generation blockchain apps. From AI-powered smart contract interactions to seamless authentication across 13+ providers, it delivers everything you need in one place.

Build Web3 apps with Web2-level simplicity—no more juggling multiple services or fragmented workflows. Everything you need is streamlined into a consistent, reliable interface.

One universal flow for all modern authentication methods:

• 13+ OAuth Providers – Google, Apple, Discord, GitHub, X, Coinbase, Farcaster, and more
• Modern Methods – SMS, Email, Passkeys, SIWE
• Custom – JWT tokens, custom endpoints

POST /v1/auth/initiate
POST /v1/auth/complete

Result: User wallet + JWT token, ready to use.

• Authentication – Universal flow for all methods
• Wallets – Balances, transactions, NFTs, signing, transfers
• Contracts – Deploy, read, write, manage
• Transactions – Advanced management & monitoring
• Payments – Token swaps, hosted checkout
• Tokens – Discovery & ownership tracking
• AI – Natural language blockchain interactions

AI Blockchain Control

POST /ai/chat

Deploy contracts, run DeFi strategies, or send transactions in plain English.

Payment Infrastructure
Optimal token swaps, hosted checkouts, ETH/ERC-20/NFT support.

Smart Contract Tools
Batch operations, auto-deploy, real-time data, rich metadata.

Cross-Chain Ready
Query balances, send transactions, and deploy on any chain.

• Gaming & NFTs – In-game trading, marketplaces, multi-chain economies
• DeFi & Payments – Cross-chain payments, automated strategies
• Enterprise – Corporate wallets, supply chain tracking, tokenized rewards
• Consumer Apps – Social tokens, creator platforms, subscriptions

• Docs: api.thirdweb.com/reference
• Quick Start: Auth, Smart Contracts, AI, Payments

Build faster. Scale easier. Launch smarter with the thirdweb API.

Arbitrum Stylus brings a second, WebAssembly (WASM) virtual machine to every Arbitrum chain, so you can write contracts in Rust (or C/C++) while staying 100 % interoperable with existing Solidity code.

Under the hood, Stylus executes WASM thousands of times faster than the EVM, so transactions are metered in a new, much-smaller unit called ink rather than gas — translating to dramatic fee savings for compute- or memory-heavy logic.

To take advantage of the interoperability and fee savings, we are working with Arbitrum to bring you thirdweb contract developer tooling to Stylus

• Airdrop tokens pre-built smart contracts available on Explore
  • Airdrop ERC-20
  • Airdrop ERC-721
  • Airdrop ERC-1155
• ERC-20, ERC-721, and ERC-1155 token templates written in Stylus available to deploy through the CLI.

| Learn how to deploy and interact with Stylus contracts through thirdweb documentation

• Deploy contracts written with Stylus through the thirdweb

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

• Publish Stylus-written contracts through the thirdweb CLI

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

• Interact with Stylus contracts using thirdweb SDKs.

Learn how to do this through the Stylus guide.

Stylus + thirdweb lets you trade Solidity’s familiar syntax for Rust’s performance without losing any of the tooling you love, and simplifies your deployment and tooling integration.

We will be creating additional contracts with Stylus. If you are interested in being notified on release or have any feedback, please join our Telegram community and let us know.

• thirdweb Arbitrum Documentation
• Arbitrum Stylus Documentation
• Stylus Airdrop ERC-721 Template

Need help? Please reach out to our support team.

A cleaner, smarter interface to help you discover features and navigate the Playground more efficiently.

• New home page with Table of Contents
• Updated product grouping in the sidebar
• Clearer titles and descriptions
• A cleaner and more user friendly sidebar
• Added light mode support

Breaking Change: /v1/nfts/transfers Requirements

• Requests to /v1/nfts/transfers now require at least one of the following parameters:
  • block_timestamp_from
  • block_number_from

Status: Read-Only (No New Blocks)

• The following chain IDs have been deprecated and will no longer receive new block updates
• Historical data remains accessible for all deprecated chains
• Affected Chain IDs: 30, 302, 919, 5031, 6283, 9746, 9899, 11690, 16600, 31911, 41455, 42019, 42026, 98865, 555271, 555272, 978658, 4457845, 28122024, 168587773, 531050104, 1660990954, 2734060341882000

• Update any /tokens/transfers paginated requests to include required time or block range parameters
• Consider migrating from deprecated chains to active alternatives where applicable

The Transactions API now supports EIP7702 session key authorization for gasless transaction execution. Server wallets can execute transactions on behalf of user accounts with full gas sponsorship from the infrastructure.

Implementation

curl -X POST "https://engine.thirdweb.com/v1/write/transaction" \
  -H "content-type: application/json" \
  -H "x-secret-key: <your-secret-key>" \
  -d '{
    "executionOptions": {
      "type": "EIP7702",
      "chainId": "84532",
      "sessionKeyAddress": "<server-wallet-address>",
      "accountAddress": "<user-account-address>"
    },
    "params": [
      {
        "to": "0x...",
        "data": "0x...",
        "value": "0x0"
      }
    ]
  }'

Parameters

• sessionKeyAddress: Server wallet address with session key authorization
• accountAddress: User account that issued the session key
• type: Must be set to EIP7702 for session key execution
• Gas costs: Fully sponsored by Transactions API infrastructure

Your server wallet must be registered as authorized session key signer on the accountAddress you want to send this transaction on behalf of.

We just enabled batch execution for EOAs, allowing you to execute multiple transactions atomically in a single call.

How to use batch execution

Simply pass multiple items in your params array. All transactions will be executed atomically:

curl -X POST "https://engine.thirdweb.com/v1/write/transaction" \
  -H "content-type: application/json" \
  -H "x-secret-key: <your-secret-key>" \
  -d '{
    "executionOptions": {
      "type": "EOA",
      "chainId": "84532",
      "from": "<your-eoa-address>"
    },
    "params": [
      {
        "to": "0x...",
        "data": "0x...",
        "value": "0x0"
      },
      {
        "to": "0x...",
        "data": "0x...",
        "value": "0x0"
      },
      {
        "to": "0x...",
        "data": "0x...",
        "value": "0x0"
      }
    ]
  }'

EOA Upgrade Required

Engine uses EIP7702 internally for batch execution, which requires your EOA to be "upgraded". If your EOA isn't already upgraded, you can send a no-op EIP7702 transaction to upgrade it:

curl -X POST "https://engine.thirdweb.com/v1/write/transaction" \
  -H "content-type: application/json" \
  -H "x-thirdweb-secret-key: <your-secret-key>" \
  -d '{
    "executionOptions": {
      "type": "EIP7702",
      "chainId": "84532",
      "from": "<your-eoa-address>"
    },
    "params": [
      { "to": "<your-eoa-address>"}
    ]
  }'

After this upgrade transaction, you can use batching with the same EOA.

Happy building! 🛠️

You can now instantly swap between tokens and chains using any thirdweb wallet with the https://api.thirdweb.com/v1/payments/swap endpoint. Using exact you can toggle between specifying an input and output amount to be received. Learn more and see the full reference here.

We just enabled AWS KMS wallet support for the Transactions API, allowing you to use your AWS KMS-managed keys directly.

How to use AWS KMS wallets

Add the AWS KMS headers to your Engine API calls:

curl -X POST "https://engine.thirdweb.com/v1/write/transaction" \
  -H "content-type: application/json" \
  -H "x-secret-key: <your-secret-key>" \
  -H "x-aws-kms-arn: <your-kms-key-arn>" \
  -H "x-aws-access-key-id: <your-access-key>" \
  -H "x-aws-secret-access-key: <your-secret-key>" \
  -d '{
    "executionOptions": {
      "type": "EOA",
      "chainId": "1",
      "from": "<your-kms-wallet-address>"
    },
    "params": [{
      "to": "0x...",
      "data": "0x...",
      "value": "0x0"
    }]
  }'

Migrating from Engine v2?

If you're using AWS KMS wallets with Engine v2, you can now migrate to Engine Cloud seamlessly using the same KMS configuration.

Please avoid using EOA execution on both Engine v2 and Engine Cloud simultaneously with the same wallet on the same chain - this will cause nonce conflicts. Consider testing your integration on a different chain, and them migrating fully.

Happy building! 🛠️

We've made significant changes to how the payment widgets (BuyWidget, CheckoutWidget, and TransactionWidget) generate quotes for every available token. This allows users to find the best possible quote available to them, rather than needing to guess with token to pay with.

Try the improved quote discovery in our playground or on version 5.105.24 or later of the React SDK.

Unreal Engine 5.6 is now supported by thirdweb's Unreal Plugin.

You can download the plugin from our Github Release.

This release is also available on the Fab marketplace!

thirdweb Payments have made it easy to integrate monetization tools into apps with drop-in widgets and SDKs. Now, we're making it even easier with hosted payment links.

You can get paid by anyone, anywhere, and in any token using thirdweb's Payment Links. Links can be created in the dashboard or via the payments API. We've also redesigned our payment's dashboard for easier feature discovery and usage.

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.

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

You can find the latest release on Github.

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.

• New HTTP API → We created a new API which combines all services with a simplified interface. Optimized for humans and agents.
• New MCP server → Interact with the thirdweb platform from your favorite LLM client.
• New LLM-optimized documentation → inject these into your prompts to instruct coding agents to build with thirdweb
• New Project and documentation organization → Projects and docs are now organized to follow the new product structure

• 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

Check out the full api reference.

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.

Check out our new MCP documentation for more details.

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.

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.

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

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.

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.

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

• Go to your team in the dashboard and click on the Support tab
• For support SLAs by plan, visit: thirdweb.com/pricing
• For general response time expectations, see: portal.thirdweb.com/knowledge-base#3-response-time-expectations

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

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

We just enabled EIP7702 for server wallets, resulting in 4x faster sponsored transactions from sending to confirming when compared to ERC4337 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!

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.

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.

Checkout the updated layout for some popular tokens

• USDC on Base
• USDC on ethereum
• Shiba Inu on ethereum

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

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

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

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"]
      }
    ]
  }'

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

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!

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!

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!

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.
  

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

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

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

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!

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

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

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.

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

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.

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

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}

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

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

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 →

• 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

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

.NET Release | NuGet Release | Unity Release

Documentation | Support

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!

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

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

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.

• 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

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

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

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.

.NET Release | NuGet Release | Unity Release

Documentation | Support

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!

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

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.

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

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.

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!

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:

View example page

View example page

View example page

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

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.

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.

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

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

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

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

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

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

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!

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.

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.

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.

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.

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.

• 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

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.

• 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

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.

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.

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.

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.

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

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!

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.

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

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

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

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.

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

3. Handle Events
   Every newHeads message includes block number, hash, timestamp, and parent hash—ready for indexing, alerts, or analytics.

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

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.

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

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.