Changelog

We’ve just launched a new Tokens page. With this update, you can:

• Explore tokens by popularity, trends, and chains across different networks.
• See market data - token prices, 24-hour volume, and market caps
• Swap tokens across chains using thirdweb Bridge

Try it out: thirdweb.com/tokens

We're excited to announce the release of x402 payment support in the thirdweb SDK, enabling developers to monetize their backend and agent services with seamless, automatic crypto payments.

The x402 protocol is an emerging standard that extends existing 402 HTTP error with automatic crypto payments. When an API requires payment, it responds with a 402 Payment Required status code along with payment instructions. The client can then automatically fulfill the payment and retry the request—all without user intervention beyond the initial wallet approval.
Think of it as "pay-per-call" for APIs, where each request can be individually priced and paid for using cryptocurrency.

We've added two new functions to make x402 integration effortless:

Automatically handle paid API calls with a simple wrapper around the native fetch API:

import { wrapFetchWithPayment } from "thirdweb/x402";
import { createThirdwebClient } from "thirdweb";
import { createWallet } from "thirdweb/wallets";
 
const client = createThirdwebClient({ clientId: "your-client-id" });
const wallet = createWallet("io.metamask");
await wallet.connect({ client });
 
const fetchWithPay = wrapFetchWithPayment(fetch, client, wallet);
 
// This call will automatically handle payment if required
const response = await fetchWithPay(
  "https://api.example.com/premium-data",
);
const data = await response.json();

How it works:
1. Makes the initial API request
2. If a 402 response is received, parses payment requirements
3. Verifies the payment amount is within your specified limits
4. Signs the payment authorization with your wallet
5. Retries the request with the payment header
6. Returns the successful response

Integrate x402 payments into your middleware stack with minimal configuration. Works with all the existing x402 middleware libraries already out there. Here's an example with x402-next

import { createThirdwebClient } from "thirdweb";
import { facilitator } from "thirdweb/x402";
import { paymentMiddleware } from "x402-next";
 
const client = createThirdwebClient({
  secretKey: process.env.THIRDWEB_SECRET_KEY,
});
 
export const middleware = paymentMiddleware(
  "0xYourRecipientWallet",
  {
    "/api/premium-endpoint": {
      price: "$0.01",
      network: "base-sepolia",
      config: {
        description: "Access to premium AI features",
      },
    },
    "/api/data-analysis": {
      price: "$0.05",
      network: "base-sepolia",
      config: {
        description: "Advanced data processing",
      },
    },
  },
  facilitator({
    client,
    serverWalletAddress: "0xYourServerWallet",
  }),
);
 
export const config = {
  matcher: ["/api/premium-endpoint", "/api/data-analysis"],
};

Try the Live Demo
Experience x402 payments in action at our interactive playground.

Read the Documentation
Get detailed implementation guides in our x402 documentation.

Stay tuned for more x402 utilities and expanded functionality in the next few weeks!

Happy building! 🛠️

We've deployed new and improved bridge contracts that affect our Payments, Bridge, and Tokens products. The new contracts come with a variety of improvements including:

• Better execution prices and slippage resistance
• More informative events for transaction indexing
• Dynamic protocol fees for high-volume users

The new contracts are being iteratively deployed to all chains in the coming days. During the deployment period, users may be prompted to interact with a new contract.

Old Contract: 0xF8Ab2dBE6c43bf1a856471182290f91D621Ba76d

New Contract: 0x7d34a477e2678c8e19d821eec103d4def4af6f4a

ZK Contract: 0xC8EF2D40Ef314bb433f86ce2b67bA880BB48771b

The Nebula first party app - nebula.thirdweb.com - will be deprecated September 30th 2025 in favor of thirdweb AI.

If you have any funds in the nebula in-app wallet - please withdraw them by September 30th 2025.

To continue using the service, head over to the thirdweb dashboard and create a project. You will find the same functionality as before under the AI tab.

We will be shipping continuous updates and improvements to thirdweb AI in the next few weeks, stay tuned for announcements!

At thirdweb, our mission is to help builders succeed — from those starting their first project to teams scaling to millions of users. To keep improving, we’ve added a new feedback and rating feature in support in dashboard after ticket closure.

1. Go to your thirdweb dashboard, and at the team level, click Support from the left menu.
2. Open and create tickets or cases directly from there.
3. After an interaction with our AI agent or support team, and once your ticket is closed, you’ll see the option to:
   • ⭐ Leave a star rating
   • 💬 Add a quick comment about your experience

We take your feedback seriously. Every rating helps us identify what’s working well and where we can improve. This ensures we continue building the best tools and providing the best support for builders like you.

Our support team is here to help you integrate thirdweb and bring your ideas to life. Different plans come with different SLAs, which you can check out here: thirdweb.com/pricing.

We appreciate every single customer and your feedback is key to making thirdweb the best tool for builders. 🚀

• Endpoint: GET /v1/bridge/chains
• Description: Retrieves a list of blockchain networks supported for bridging.
• Details:
  • Returns chain ID, name, icon, and native currency details

Example Response:

{
  "result": [
    {
      "chainId": 1,
      "name": "Ethereum Mainnet",
      "icon": "https://...",
      "nativeCurrency": {
        "name": "Ether",
        "symbol": "ETH",
        "decimals": 18
      }
    }
  ]
}

• Endpoint: GET /v1/bridge/convert
• Description: Calculates the equivalent crypto token amount for a given fiat currency amount based on current market prices. This endpoint provides conversion rate estimates and does not execute any transactions.
• Parameters:
  • from (required) - Source fiat currency (broad list supported)
  • fromAmount (required) - Fiat amount (positive number)
  • chainId (required) - Target blockchain chain ID
  • to (required) - Ethereum address of the target token
• Response: Returns JSON with converted crypto amount.
• Performance:
  • Smart caching (30s fresh, 5m stale)
  • Rate-limited, requires client authentication

Example Usage:

GET /v1/bridge/convert?from=USD&fromAmount=100&chainId=42161&to=0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9

• Migration: Legacy endpoint pay.thirdweb.com/convert/fiatToCrypto replaced by /v1/bridge/convert.

Visit the full reference here.

Token Owners Endpoint (/v1/tokens/{chainId}/{address}/owners)

• Multi-standard Support: Now supports ERC-20, ERC-721, and ERC-1155 token contracts (previously ERC-20 only)
• NFT Collection Owners: Query all owners of an NFT collection without specifying a token ID
• Specific NFT Token Owners: Query owners of a specific NFT token by providing the tokenId parameter

Request Parameters

• Added optional tokenId parameter to filter NFT owners by specific token ID
  • When provided: Returns owners of the specific NFT token
  • When omitted: Returns collection-level owners for NFTs, or token holders for ERC-20, automatically detecting what kind of token it is.

Response Format

• Added optional tokenId field to owner objects in responses
  • Present for NFT queries (ERC-721/ERC-1155)
  • Absent for ERC-20 token queries

Response Behavior by Token Type

• ERC-20: Returns token holders with their balance amounts
• ERC-721 Collection: Returns owners with their token IDs and amount "1"
• ERC-721 Specific: Returns owners of the specified token ID
• ERC-1155 Collection: Returns owners with their token IDs and balance amounts
• ERC-1155 Specific: Returns owners of the specified token ID with their balance amounts

• Automatic Token Standard Detection: The API automatically detects whether a contract is ERC-20, ERC-721, or ERC-1155 using ERC-165
• Enhanced Error Handling: Better error messages specific to each token standard
• Consistent Pagination: All token types now return consistent pagination metadata (hasMore, limit, page)

• Updated OpenAPI specifications with examples for all supported token standards
• Clarified what the amount field represents for different token types

Every project in the thirdweb dashboard now comes with a dedicated AI chat. Think of it as your dev companion in your web3 building journey.

• Transact with your connected dashboard wallet
• Swap tokens with your connected dashboard wallet
• Deploy contracts with rich metadata
• Ask about contract addresses, ABI, events, transactions, etc
• Ask about chain stats, block info, etc
• Ask about a wallet transactions, tokens, nfts, etc
• Query contract state
• Upload files to IPFS
• Convert units, encode or decode data, etc
• Debug transactions
• and more!

• View all past conversations, including the ones created programmatically from your apps
• Track token usage
• Auto execute transactions with your server wallets (coming soon!)

All of these make thirdweb AI a great sidekick during and post development. Head over to your project dashboard and give it a spin!

We've rebranded Nebula to thirdweb AI - now generally available via dashboard and API. As part of this change, nebula.thirdweb.com will be sunsetted on September 30th 2025. Please migrate any assets from it before that.

For a while, we offered Payments as an all-in-one solution. It helped developers handle everything from accepting crypto payments to moving tokens across chains. But as we grew, we noticed the needs for a crypto checkout and a crypto bridge becoming distinct amongst users.

That’s why we’re breaking out our product and re-introducing Bridge alongside Payments.

Bridge is built for token transfers and swaps across any chain. Instantly move assets where you need them whether that’s supporting cross-chain dApps, enabling multi-chain liquidity, or powering user experiences that feel seamless across the EVM network.

Payments is focused on accepting crypto payments for goods and services. It gives businesses and developers a simple, reliable way to collect crypto from users with all the tools you need to map your onchain checkout flow to offchain actions such as accounting or completing orders.

When everything lived under “Payments,” it blurred the lines. Some needed a checkout solution, while others needed a cross-chain infrastructure tool.

By separating the products, we aim to:

• Make it easier for you to choose the right tool for the job.
• Double down on specialized improvements for each product.
• Offer clearer docs, examples, and support paths depending on whether you’re building with Payments or Bridge.

We are deprecating the following endpoints: /payments/swap and /tokens/swap in favor of the new Bridge endpoint /bridge/swap. This deprecation will not break your application but we encourage you to swap out this endpoint to ensure you are up to date and receive the subsequent updates to the endpoint.

👉 Learn more about this change.

You will also notice a breakout of Payments and Bridge on dashboard and in our documentation.

👉 View the updated Payments documentation

👉 View the new Bridge documentation

👉 View the API reference

This update doesn’t affect your existing integrations right away — but moving forward, you’ll see dedicated updates, features, and roadmaps for both.

We appreciate your patience with all the changes!

If you have any further questions or need support in regards to this update, please do not hesitate to reach out.

As part of ongoing efforts to streamline and maintain our API, we are deprecating several Insight Service endpoints that have seen limited usage.

The following endpoints will be deprecated:

• GET /v1/transactions/{contractAddress}/{signature}
• GET /v1/tokens/transfers/transaction/{transaction_hash}
• GET /v1/contracts/deployed-by/{address}
• GET /v1/contracts/metadata/{address}
• POST /v1/decode/{address}
• GET /v1/nfts/transfers/transaction/{transaction_hash}

• Deprecation Announcement: Effective immediately.
• Deprecation Period: These endpoints will remain available for 30 days to allow for migration.
• Removal Date: After the deprecation period, these endpoints will be permanently disabled.

• Existing applications that call these endpoints will need to migrate to supported alternatives.
• If your integration does not use these endpoints, no action is required.

• For transaction-related insights: use GET /v1/transactions.
• For token transfers: use GET /v1/events with filters.
• For NFT transfers: use GET /v1/events with transaction or address filters.

(Please refer to our latest [API documentation] for details.)

You can now specify custom slippage tolerance on the /bridge/swap endpoint. With the slippageToleranceBps parameter, you can specify how many basis points in slippage your swap can tolerate. Warning: Lower slippage tolerance values could result in reverted swaps.

Without this value specified, it will continue to use the default behavior of automatically calculated slippage tolerance.

curl https://api.thirdweb.com/v1/bridge/swap \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_SECRET_TOKEN' \
  --header 'x-client-id: YOUR_SECRET_TOKEN' \
  --data '{
  "exact": "input",
  "tokenIn": {
    "address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    "chainId": 42161,
    "amount": "100"
  },
  "tokenOut": {
    "address": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
    "chainId": 42161,
    "minAmount": "80"
  },
  "from": "0xEfc38EF8C09535b25e364b6d1a7C406D3972f2A9",
  "slippageToleranceBps": 50
}'

This parameter is also available directly on the payments API. Learn more in the API reference.

The v1/wallets/{address}/tokens endpoint now exposes additional query parameters for fine-grained control over token retrieval:

New Query Parameters:

• metadata (boolean, default: true) - Include/exclude token metadata
• resolveMetadataLinks (boolean, default: true) - Resolve metadata links for richer data
• includeSpam (boolean, default: false) - Include/exclude spam tokens
• includeNative (boolean, default: true) - Include/exclude native tokens (ETH, MATIC, etc.)
• sortBy (enum, default: "usd_value") - Sort by: balance, token_address, token_price, or usd_value
• sortOrder (enum, default: "desc") - Sort order: asc or desc
• includeWithoutPrice (boolean, default: true) - Include/exclude tokens without price data

Breaking Changes:

• None - all new parameters are optional with backward-compatible defaults

Defaults Updated:

• Default sorting changed from balance to usd_value (descending)
• All inclusion filters default to maximum data coverage

Example Usage:

GET /v1/wallets/{address}/tokens?chainId=1&sortBy=usd_value&includeSpam=false&limit=50

Developer Notes:

• Existing API calls continue to work unchanged
• New defaults provide more useful token ordering (by USD value)
• Filters allow customization for specific use cases (e.g., excluding spam, metadata-only requests)

We've deprecated the /payments/swap and /tokens/swap endpoints in favor of the /bridge/swap endpoint. This endpoint behaves the same as the pre-existing swap endpoints, allowing you to perform cross-chain swaps with both input and output-centric amounts. To learn more, see the thirdweb API reference.

curl -sS -X POST "https://api.thirdweb.com/v1/bridge/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" }
  }'

New package: @thirdweb-dev/ai-sdk-provider - A thin provider that lets you plug thirdweb AI into the Vercel AI SDK.

It standardizes message parts, exposes wallet-aware tools (sign_transaction, sign_swap), and ships with types/utilities so you can build chat UIs that execute on-chain actions from AI responses.

If you’re using the Vercel AI SDK (ai / @ai-sdk/react) and want your agent to request blockchain actions safely, this provider gives you:

• A server wrapper that streams AI output and tools.
• A message schema (ThirdwebAiMessage) compatible with useChat.
• Ready-made thirdweb tools wired for signing and swaps.

npm add @thirdweb-dev/ai-sdk-provider ai @ai-sdk/react

Create a thirdweb ai provider instance and compatible with the AI SDK core by calling createThirdwebAI() with your project secret key.

import { streamText } from "ai";
import { createThirdwebAI } from "@thirdweb-dev/ai-sdk-provider";
 
const thirdwebAI = createThirdwebAI({
  secretKey: "<your-project-secret-key>",
});
 
const result = streamText({
  model: thirdwebAI.chat({
    context: {
      chain_ids: [8453], // optional chain ids
      from: "0x...", // optional from address
      auto_execute_transactions: true, // optional, defaults to false
    },
  }),
  messages: [
    {
      role: "user",
      content: "Swap 0.01 ETH to USDC",
    },
  ],
});

You can call useChat<ThirdwebAiMessage>() to get typed responses and tools. This works nicely with the AI elements components to quickly build a chat UI with blockchain capabilities.

"use client";
import { useState } from "react";
import { useChat, DefaultChatTransport } from "@ai-sdk/react";
import type { ThirdwebAiMessage } from "@thirdweb-dev/ai-sdk-provider";
 
export function Chat() {
  const { messages, sendMessage } = useChat<ThirdwebAiMessage>();
 
  // When a tool part arrives (e.g., type === "tool-sign_transaction"),
  // render a thirdweb `TransactionButton` wired to the provided input.
  return /* your UI */;
}

Checkout the playground example, for a more complete example, including how it handles session_id, renders reasoning text, and handles transaction confirmations.

• Documentation
• Playground demo
• Github repo

• On the Playground https://playground.thirdweb.com/wallets/sign-in/button
• Using the thirdweb API, fill in and run https://api.thirdweb.com/v1/auth/social?provider=tiktok&redirectUrl=&clientId= right in your browser!

• thirdweb API v1.5.2
• JS Release 5.105.32
• .NET Release 2.25.1
• Unity Release 5.25.1

We’ve introduced Auto Execution to the /ai/chat endpoint.
When enabled, the AI will not only prepare transactions, swaps, or deployments — it will automatically execute them on behalf of the authenticated user or server wallet.

This dramatically reduces friction: no extra signing steps, no manual execution flows. Just describe what you want done, and it happens.

Enable Auto Execution by setting the flag in the context object:

"context": {
  "from": "0x...",                   // the wallet address that will perform the transaction
  "chain_ids": [1],                   // optional, but recommended
  "auto_execute_transactions": true   // enable auto execution
}

If the auto execute flag is false, or no "from" address is passed in, thirdweb AI will return the prepared transactions to be signed manually like before.

Auto execution requires wallet authentication:

• User wallets → pass Authorization: Bearer <user-jwt>
• Server wallets → pass your project x-secret-key

curl --location 'https://api.thirdweb.com/ai/chat' --header 'Authorization: Bearer <user-wallet-jwt>' --header 'x-client-id: <your-client-id>' --header 'Content-Type: application/json' --data '{
    "messages": [
        {
            "content": "approve 5 USDC to joenrv.eth",
            "role": "user"
        }
    ],
    "context": {
        "from": "0x...",
        "chain_ids": [8453],
        "auto_execute_transactions": true
    }
}'

Approval transaction submitted!                                                                         
                                                                                                         
 - **Token:** USD Coin (USDC) (`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`)                             
 - **Amount:** 5 USDC (5,000,000 base units)                                                             
 - **Approved Spender:** joenrv.eth (`0x2247d5d238d0f9d37184d8332aE0289d1aD9991b`)                       
 - **Function:** approve(address,uint256)                                                                
 - **Transaction ID:** 72bb183e-9bb0-4ef4-9b52-d8df73f39ed3                                              
 - **Network:** Base                                                                                     
                                                                                                         
 Would you like to check the status of this transaction or approve a different amount?         

• Each execution returns a Transaction ID
• You can monitor this ID in your project dashboard or via the API
• You can ask the Chat API follow-up questions about this transaction:
  • “What’s the status of my approval?”
  • “Give me the transaction receipt”
  • “Show me the explorer link”

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

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