Changelog

Firekeeper

We're proud to announce initial support for Solana via the thirdweb API. This is the first of many releases making Solana more accessible to Ethereum developers.

Note: For the time being, you must create a new project from the thirdweb dashboard and use its secret key (server-side) to authenticate to the Solana APIs via the x-secret-key header.

Getting Started

All Solana endpoints are available at https://api.thirdweb.com/v1/solana/* and require authentication via the x-secret-key header:

x-secret-key: YOUR_SECRET_KEY

The API supports both Solana Mainnet (solana:mainnet) and Solana Devnet (solana:devnet) networks.


Create a Solana Wallet

Create or retrieve a managed Solana wallet using a unique label. If a wallet with the given label already exists, it will be returned instead of creating a new one.

Endpoint: POST https://api.thirdweb.com/v1/solana/wallets

Example Request:

curl -X POST https://api.thirdweb.com/v1/solana/wallets \
-H "x-secret-key: YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{
"label": "my-treasury-wallet"
}'

Example Response:

{
"result": {
"address": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"label": "my-treasury-wallet",
"createdAt": "2025-10-11T14:22:11.000Z",
"updatedAt": "2025-10-11T14:22:11.000Z"
}
}

The wallet is securely stored and can be used for signing transactions and messages.


List Solana Wallets

Retrieve all Solana wallets created for your project with pagination support.

Endpoint: GET https://api.thirdweb.com/v1/solana/wallets

Query Parameters:

  • page (optional): Page number, defaults to 1
  • limit (optional): Number of wallets per page (1-500), defaults to 100

Example Request:

curl -X GET "https://api.thirdweb.com/v1/solana/wallets?page=1&limit=50" \
-H "x-secret-key: YOUR_SECRET_KEY"

Example Response:

{
"result": {
"wallets": [
{
"address": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"label": "my-treasury-wallet",
"createdAt": "2025-10-11T14:22:11.000Z",
"updatedAt": "2025-10-11T14:22:11.000Z"
}
],
"pagination": {
"totalCount": 125,
"page": 1,
"limit": 50
}
}
}

Send Tokens

Transfer native SOL or SPL tokens with a single API call. The API automatically handles SPL token account creation if needed.

Endpoint: POST https://api.thirdweb.com/v1/solana/send

Send Native SOL

Example Request:

curl -X POST https://api.thirdweb.com/v1/solana/send \
-H "x-secret-key: YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{
"from": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"to": "FhtwVYF1wKAm7fWmE2N5P2eCv13wt2aT8W4Q9NQ9YcJH",
"amount": "1000000",
"chainId": "solana:devnet"
}'
Note: Amounts are specified in lamports (1 SOL = 1,000,000,000 lamports)

Send SPL Tokens (Like USDC)

Example Request:

curl -X POST https://api.thirdweb.com/v1/solana/send \
-H "x-secret-key: YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{
"from": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"to": "FhtwVYF1wKAm7fWmE2N5P2eCv13wt2aT8W4Q9NQ9YcJH",
"amount": "1000000",
"chainId": "solana:devnet",
"tokenAddress": "HZW5eXoaZySUdkGFwmkpfMoP1jmvYzu3PV6PvUCa3y7F"
}'

Example Response:

{
"result": {
"transactionId": "solana-tx-queue-id-abc123"
}
}

Transactions are queued and processed asynchronously. Use the returned transactionId to poll for status.


Send Transaction

For advanced use cases, submit custom Solana transactions with one or more instructions. This gives you full control over program interactions.

Endpoint: POST https://api.thirdweb.com/v1/solana/transactions

Example Request (SOL Transfer):

curl -X POST https://api.thirdweb.com/v1/solana/transactions \
-H "x-secret-key: YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{
"from": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"chainId": "solana:devnet",
"transactions": [
{
"programId": "11111111111111111111111111111111",
"accounts": [
{
"address": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"isSigner": true,
"isWritable": true
},
{
"address": "FhtwVYF1wKAm7fWmE2N5P2eCv13wt2aT8W4Q9NQ9YcJH",
"isSigner": false,
"isWritable": true
}
],
"data": "02000000e888b30000000000",
"encoding": "hex"
}
]
}'

Instruction Fields:

  • programId: The Solana program to invoke
  • accounts: Array of account metadata (address, isSigner, isWritable)
  • data: Instruction data in hex or base64 encoding
  • encoding: Either "hex" or "base64" (defaults to "base64")

Example Response:

{
"result": {
"transactionId": "solana-tx-queue-id-xyz789"
}
}

Get Transaction

Check the status of any queued transaction using its transaction ID.

Endpoint: GET https://api.thirdweb.com/v1/solana/transactions/{transactionId}

Example Request:

curl -X GET https://api.thirdweb.com/v1/solana/transactions/solana-tx-queue-id-abc123 \
-H "x-secret-key: YOUR_SECRET_KEY"

Example Response:

{
"result": {
"id": "solana-tx-queue-id-abc123",
"chainId": "solana:devnet",
"from": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"signature": "5j8k9L4mN3pQ2rS7tU6vW8xY9zA1bC2dE3fG4hH5iJ6kK7lL8mM9nN0oO1pP2qQ3rR4sS5tT6uU7vV8wW9xX0yY",
"status": "CONFIRMED",
"confirmedAt": "2025-10-11T14:23:45.000Z",
"confirmedAtSlot": "123456789",
"blockTime": 1728654225,
"createdAt": "2025-10-11T14:23:11.000Z",
"errorMessage": null,
"clientId": "your-client-id"
}
}

Transaction Statuses:

  • QUEUED: Transaction is waiting to be submitted
  • SUBMITTED: Transaction has been submitted to the network
  • CONFIRMED: Transaction is confirmed on-chain
  • FAILED: Transaction failed (check errorMessage for details)

Sign Message

Sign arbitrary messages with your Solana wallet. Supports both plain text and hexadecimal formats with automatic detection.

Endpoint: POST https://api.thirdweb.com/v1/solana/sign-message

Example Request (Plain Text):

curl -X POST https://api.thirdweb.com/v1/solana/sign-message \
-H "x-secret-key: YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{
"from": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"message": "Welcome to my dApp!"
}'

Example Request (Hex Format):

curl -X POST https://api.thirdweb.com/v1/solana/sign-message \
-H "x-secret-key: YOUR_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{
"from": "8JBLmveV4YF5AQ7EVnKJgyj6etGgVkPp3tYqQMTu3p5B",
"message": "0x48656c6c6f20536f6c616e61"
}'

Example Response:

{
"result": {
"signature": "5Nftk1W4nN6Xr2y4griH4sHqY2cD3rPrXg5BDJ9Y6hHSF3oURaUz6VXo4Qzv6TQ2Jj3MdE4Y5nVkq"
}
}

The signature is returned in Base58 format and can be used for authentication and verification.


Coming Soon

We're actively working on expanding our Solana support. Here's what's coming next:

Official thirdweb Solana RPCs

High-performance, globally distributed RPC endpoints optimized for Solana applications.

Solana Swap API

Seamlessly swap tokens on Solana with the best rates from top DEXs like Jupiter and Raydium.

Solana Token Deployment API

Deploy your own SPL tokens with a single API call, including support for Token-2022 program features.


Need Help?

We can't wait to see what you build with Solana on thirdweb! 🚀

Yash Kumar

We have added support for creating and deploying ZK Proof based token contracts with Stylus. The templates provide you with Stylus contracts, ZK circuit files, and a ready-to-deploy Next.js app + API for proof generation and minting.

This guide walks you through building a privacy-preserving ERC721 token system using Zero-Knowledge proofs on Arbitrum Stylus. Users can mint tokens by proving they own a minimum amount of ETH without revealing their exact balance.

What You'll Build

  • ZK Circuit: Proves token ownership without revealing exact balances
  • Stylus Contract: Rust-based ERC721 contract that verifies ZK proofs
  • Frontend: Next.js app for generating proofs and minting tokens
  • Oracle System: Secure balance verification mechanism

Prerequisites

Step 1: Project Setup

Using thirdweb CLI

npx thirdweb create-stylus

Select "Stylus ZK ERC721" from the dropdown menu. This will:

  • Clone the repository to your machine
  • Set up the project structure
  • Install basic dependencies

Manual Setup (Alternative)

git clone https://github.com/thirdweb-example/stylus-zk-erc721.git
cd stylus-zk-erc721

Step 2: Install Dependencies

Install dependencies for all components:

# Install root dependencies
pnpm install
# Install circuit dependencies
cd circuits
pnpm install
cd ..
# Install frontend dependencies
cd app
pnpm install
cd ..

Step 3: Generate Cryptographic Keys

Run the setup script to generate oracle keys and build the ZK circuit:

chmod +x setup.sh
./setup.sh

This script will:

  • Generate a random oracle secret key
  • Inject the secret into the ZK circuit
  • Compile the circuit with circom
  • Generate proving and verification keys
  • Create the trusted setup for Groth16

⚠️ Important: The oracle secret is critical for security. Keep it private!

Step 4: Deploy the Contract

Using thirdweb CLI

cd contracts
npx thirdweb@latest deploy-stylus -k <THIRDWEB_SECRET_KEY>

Using Stylus CLI (Alternative)

cd contracts
cargo stylus deploy --endpoint arbitrum-sepolia

Copy the deployed contract address - you'll need it for the frontend.

Step 5: Configure the Frontend

Update the contract address in your frontend:

cd app
# Edit pages/index.tsx or lib/config.ts
# Update ZK_MINT_CONTRACT_ADDRESS with your deployed address

Create environment file:

# app/.env.local
RPC_URL=https://sepolia-rollup.arbitrum.io/rpc
ORACLE_SECRET_KEY=<your_oracle_secret_from_setup>

Step 6: Run the Application

cd app
pnpm dev
# Visit http://localhost:3000

Step 7: Test the System

  1. Connect Wallet: Connect to Arbitrum Sepolia testnet
  2. Generate Proof: Click "Generate ZK Proof" - this proves you have sufficient balance
  3. Mint Tokens: Use the proof to mint ERC721 tokens

Customizing the ZK Logic

Understanding the Circuit

The core circuit (circuits/token_ownership.circom) has these components:

template TokenOwnership(oracle_secret) {
// Private inputs (hidden from public)
signal input actual_balance; // Real balance from oracle
signal input salt; // Randomness for uniqueness
// Public inputs (visible on-chain)
signal input min_required_balance; // Minimum threshold
signal input token_contract_hash; // Which token to check
signal input user_address_hash; // User's address hash
signal input timestamp; // When oracle signed data
signal input oracle_commitment; // Oracle's commitment
// Output
signal output nullifier; // Prevents replay attacks
}

Customization Examples

1. Change Balance Threshold Logic

Replace the balance check with custom logic:

// Original: Simple greater-than check
component gte = GreaterEqThan(64);
gte.in[0] <== actual_balance;
gte.in[1] <== min_required_balance;
gte.out === 1;
// Custom: Logarithmic scaling
component log_check = LogarithmicCheck();
log_check.balance <== actual_balance;
log_check.threshold <== min_required_balance;
log_check.out === 1;

2. Add Multiple Token Support

Extend the circuit to verify multiple token balances:

template MultiTokenOwnership(oracle_secret, num_tokens) {
signal input actual_balances[num_tokens];
signal input min_required_balances[num_tokens];
signal input token_addresses[num_tokens];
// Verify each token separately
component checks[num_tokens];
for (var i = 0; i < num_tokens; i++) {
checks[i] = GreaterEqThan(64);
checks[i].in[0] <== actual_balances[i];
checks[i].in[1] <== min_required_balances[i];
checks[i].out === 1;
}
}

3. Add Time-Based Constraints

Add expiration logic to proofs:

// Add time validation
component time_check = LessThan(64);
time_check.in[0] <== timestamp;
time_check.in[1] <== max_timestamp; // New public input
time_check.out === 1;

Rebuilding After Changes

After modifying the circuit:

cd circuits
pnpm run build
# Re-inject verification keys
cd ..
node scripts/inject-vk.js
# Recompile contract
cd contracts
cargo build

Additional Resources

Support

Need help? Please reach out to our support team.

Manan Tank

We’ve made several updates to the BuyWidget component to make it more flexible, interactive, and user-friendly - giving users more control while simplifying integration.

New BuyWidget UI

Token and Chain selection can now be changed in the widget UI

Clicking on the selected token opens a Modal that allows changing the selected chain and token. chain, and amount props are now optional

Both fiat and token amounts are editable

Both the fiat and token amount fields can be edited, making it easier to input custom fiat amounts beyond just selecting the suggested fiat amounts.

The wallet's current balance is also shown in the bottom-right corner which helps in choosing the buy amount

Connected wallet displayed

A button is added on the top-right corner that shows the connected wallet, Clicking on it opens the Wallet Details modal, which allows switching the active wallet or disconnecting the wallet

Try it out

Try out the new and improved BuyWidget in playground

Firekeeper

TLDR: The thirdweb API from fields when transacting are now optional - this is powered by the newly launched Project Wallets - go set one up!

What’s new

When you’re orchestrating transactions from your backend, repeating the same sender address in every payload is the definition of busywork. Starting today, you can skip it. Authenticate with your project’s secret key, leave off the from field, and we’ll launch those transactions straight from your project wallet.

  • Automatic sender fallback for server-side flows that use your project secret key.
  • Works everywhere you submit encoded calls, trigger wallet actions, deploy or write contracts, mint tokens, process payments, or swap via the bridge API.
  • Still honors explicit from values when you need to override the default.

Why you’ll love it

Removing boilerplate means less room for typos, quicker prototyping, and cleaner shared helpers. Your integrations stay lean while every transaction still resolves to the right wallet.

Try it now

curl https://api.thirdweb.com/v1/transactions \
-H "Content-Type: application/json" \
-H "x-secret-key: <your-secret-key>" \
-d '{
"chainId": 421614,
"transactions": [
{
"data": "0x",
"to": "vitalik.eth",
"value": "0"
}
]
}'

No from required—just the secret key that unlocks your project wallet.

Firekeeper

We’ve introduced Project Wallets as a first-class part of the dashboard so every project comes with a managed server wallet you can see, fund, and control right from the overview screen.

Persistent wallet card

The Project Wallet section will stick around under Overview, giving teams a home base for balances, addresses, and actions.

Send funds or refresh balances right from the card, with labels and addresses trimmed for clarity.

Send & receive in one place

Kick off transfers or open the funding modal without leaving the page.

Change the default wallet

When multiple server wallets exist, pick a new default directly from the card. The change propagates instantly across integrations.

Other Integrations

You can autifill your project wallet in the Create a Payment and Earn Fees flows.

Secure

When using a managed Vault, you can use your secret key to interact with the Project Wallet - if you eject from the managed Vault, you may be prompted for an additional vault access token to interact with it. Via API, this looks like an additional x-vault-access-token header.

What’s next

  • Integration for gasless deployments — Token and Contract flows
  • Integration into thirdweb API — will be used when a from address is not specified for your backend flows.
  • Integration into any Transaction Button ("Execute" flow) you might encounter during your dashboard journey, from places like contract explorers for example.

Links

Create a new project now!

Feel free to provide feedback @ https://thirdweb.com/support

Joaquim Verges

You can now pay for any x402 compatible endpoint using the the new /v1/payments/x402/fetch API.

What's new

The new /v1/payments/x402/fetch in the thirdweb API proxies any url, and upon receiving HTTP 402 payment required response, automatically handles the payment with the authenticated wallet.

Query params

  • url - target endpoint to fetch
  • from - the wallet address to pay with
  • method - optional HTTP method for the endpoint to fetch (defaults to POST)
  • maxValue - optional max amount that can be paid
  • asset - optional payment token, if not specified defaults to the target endpoint payment method
  • chainId - optional payment chain, if not specified defaults to the target endpoint payment chain

Request body and headers will be forwarded to the target url.

Usage

You can use this from any language, any platform. Use it with your server wallets (using your project secret key) or with user in-app wallets (using the user JWT).

This makes is much easier to implement x402 payments for apps and agents.

Simply call this endpoint in your frontend or your agent tool to automatically pay for any x402 compatible endpoint.

Learn more

Happy building! 🛠️

Firekeeper

New Endpoints

We just shipped a pair of routes that make it painless to manage external wallets (via Sign-In-With-Ethereum aka SIWE) and other common authentication methods on user accounts. Both endpoints live under https://api.thirdweb.com and return fully normalized linked-account data so you don’t have to juggle different provider shapes.

POST /v1/auth/link

Link an additional authentication method or wallet to your account.

Authentication Required: Client token + Wallet token

Request Body:

{
"accountAuthTokenToConnect": "string"
}

Response:

{
"linkedAccounts": [
{
"type": "siwe" | "guest" | ...,
"id": "string",
"details": { ... }
}
]
}

POST /v1/auth/unlink

Unlink an authentication provider from your account.

Authentication Required: Client token + Wallet token

Request Body:

{
"type": "siwe" | "guest" | ...,
"details": {
"address": "0x...", // optional
"walletAddress": "0x...", // optional
"email": "...", // optional
"phone": "...", // optional
"id": "..." // optional
},
"allowAccountDeletion": false // optional
}

Note: At least one identifier in details is required.

Response:

{
"linkedAccounts": [
{
"type": "siwe" | "guest" | ...,
"id": "string",
"details": { ... }
}
]
}

Joaquim Verges

We're continuously improving support for HTTP 402 payments in our SDK and facilitator API. Here's what shipped this week.

What’s new

  • Facilitator waitUntil option: Choose when a payment is considered fulfilled — simulated, submitted, or confirmed.
  • Signature auto-detection: SDK now detects the correct signature type and EIP-712 domain/version based on asset address. No need to configure manually.
  • Filters in /supported API: Filter supported tokens by chain or asset.
  • New /prepare API: sign and encode payment payloads directly with the authenticated wallet.
  • Revamped Playground: Select any token and try different config options in the UI. https://playground.thirdweb.com/payments/x402
  • Documentation refresh: Updated guides for client, server, and facilitator APIs. https://portal.thirdweb.com/payments/x402

In case you missed it, here's what we shipped last week:

Happy building! 🛠️

Firekeeper

Thirdweb Unity SDK v6 – Official Release

Migration Guide

Size & Performance Improvements

  • Reduced dependencies — fewer DLLs, all updated to the latest major versions.
  • Unity package size cut by 40%.
  • Significant performance gains across wallet APIs.
  • Includes all performance upgrades from the .NET SDK v3 release, plus full access to the Thirdweb API wrapper via ThirdwebClient.Api. (See .NET release notes for details.)

Reown AppKit Integration

  • Removed: MetaMaskWallet and WalletConnectWallet.
  • Added: Reown AppKit, the improved successor to WalletConnect.
    • If you rely on external wallets, migrate to AppKit — it’s more stable, faster, and actively maintained.
    • AppKit is optional and not bundled with the SDK. If you call ConnectWallet with WalletProvider.ReownWallet without setting it up, you’ll see descriptive errors guiding you through one-time setup.
    • Check the Migration Guide if you get stuck.

Unified Playground

  • PlaygroundManager has been simplified for readability and ease of use.
  • The sample scene now includes the most common SDK features pre-wired for quick testing.
d0a286328fc7445dbc310a33fd449366

Full Changelog: v5.26.0 → v6.0.0


Thirdweb .NET SDK v3 – Official Release

Why Upgrade to v3

  1. Unified client and APIs
  2. Faster, lighter, and more efficient
  3. Modern dependencies and standards
  4. Easier wallet and transaction testing
  5. Architecture ready for future features

Thirdweb .NET SDK v3 evolves from separate utilities into a cohesive, high-performance platform.

Major Architectural Changes

Unified API Client

// v2 – Separate clients
var nebula = await ThirdwebNebula.Create(client);
var pay = new ThirdwebPay();
var bridge = await ThirdwebBridge.Create(client);
var insight = await ThirdwebInsight.Create(client);
// v3 – Unified client
var response = await client.Api.JustDoItAsync(...);

Highlights

  • Low level generated client for thirdweb API full access, will be kept updated and the time-save will be used to make higher level APIs with nicer DX similar to the remaining ThirdwebWallet, ThirdwebContract and ThirdwebTransaction APIs.
  • Consistent API design
  • Easier discovery via IntelliSense
  • Wraps the thirdweb API with all its features vs waiting for manual higher level integration
  • Wrapper customized and adapted to work across any runtime and extended for game engine use.

Note that the core thirdweb functionality of Wallets, Contracts and Transactions is effectively free of breaking changes (new features are available). In the future, they may call into ThirdwebClient.Api while maintaining the nicer DX. There will eventually be an opinionated easier to use wrapper for each service.


Wallet System Updates

Modernized Wallet Flow

// v2 – Private key wallet
var privateWallet = await PrivateKeyWallet.Generate(client);
// v3 – Guest/in-app wallets
var wallet = await InAppWallet.Create(client, AuthProvider.Guest);
await wallet.LoginWithGuest();

Improvements

  • Removed legacy signing and recovery methods from the IThirdwebWallet interface
  • Removed obsolete LegacyEncryptionKey creaton param from In-App and Ecosystem Wallets.
  • Major internal cleanup of legacy Shamir sharding client side logic and AWS logic.
  • Better guest wallet flows
  • Smarter gas handling and bundler integration

Performance & Dependencies

  • Removed Portable.BouncyCastle and two other Nethereum dependencies.
  • Updated remaining Nethereum dependencies to Nethereum 5.0.0
  • Creating an In-App or Ecosystem wallet should feel a lot faster now.

Efficiency Gains

  • 30% less code (6,997 → 4,886 lines)
  • 41% fewer files (44 → 26)
  • Faster builds and smaller runtime

Developer Experience

Transactions

var hash = await transaction.Send();
var receipt = await transaction.SendAndWaitForTransactionReceipt();

Build System

  • Modernized for faster development and testing
  • If you want to contribute, we have a nice Makefile to help run things more easily

Account Abstraction

  • Unified bundler (ThirdwebBundler)
  • Improved gas estimation and sponsorship
  • Better EIP-7702 support
  • Better zkSync integration

Links

Firekeeper

🍎 Native macOS OAuth Browser Support

✨ New Features

  • Native OAuth Integration: Added support for OAuth (social login) flows on macOS standalone builds using ASWebAuthenticationSession, integrated into the default CrossPlatformUnityBrowser.
  • Universal Binary Support: Ships with an optimized native plugin (libMacBrowser.dylib) containing both ARM64 and x86_64 architecture support.

🔧 Improvements

  • Enhanced Security & UX: OAuth flows now use the system’s native web authentication session for better security, user experience, and compliance with App Store review guidelines.
  • Improved Redirect Handling: Redirects now deeplink back into the app instead of following the Desktop Windows–style flow.
  • Refined Platform Detection: macOS is now properly detected and handled in authentication workflows.
  • Browser Selection Logic: Updated to ensure seamless use of the native macOS session.

📦 What’s Included

  • Native macOS plugin (libMacBrowser.dylib)
  • MacBrowser class implementation
  • Build instructions for compiling the plugin
  • Updated browser selection logic for macOS builds

Note: This functionality only works in builds. In the Unity Editor, the original flow will still open a full browser.


Release: https://github.com/thirdweb-dev/unity/releases/tag/v5.26.0

Yash Kumar

We've redeployed bridge contracts with some updates that affect our Payments, Bridge, and Tokens products.

Users may be prompted to interact with a new contract.

  • Old Contracts: 0xF8Ab2dBE6c43bf1a856471182290f91D621Ba76d, 0x7d34a477e2678c8e19d821eec103d4def4af6f4a
  • New Contract: 0xdA864364f7D1ebCC7C89e9610eBdef45dDf5F81B
  • ZK Contract: 0xC8EF2D40Ef314bb433f86ce2b67bA880BB48771b
Joaquim Verges

We've updated our x402 facilitator and SDK to support any token that supports ERC-2612 permit functionality. Supporting this popular signature standard opens up x402 payments to virtually any ERC20 token.

What's new

  • x402 facilitator and SDK now auto-detects ERC-2612 permit vs ERC-3009 transferWithAuthorization (USDC) and uses the right flow.
  • settlePayment and verifyPayment now accept any arbitrary chain.

Example

Client: pay-gated fetch using x402
auto detects ERC-2612 permit when supported, and signs the payment data accordingly.

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"); // or any other wallet
await wallet.connect({ client });
const fetchWithPay = wrapFetchWithPayment(fetch, client, wallet);
// Make a request that may require payment
const response = await fetchWithPay(
"https://api.example.com/paid-endpoint",
);

Server: verify and settle via facilitator
When verifying/settling the payment define the price in the ERC20 token of your choice. Here's an example using $higher.

import { createThirdwebClient, toWei } from "thirdweb";
import { facilitator, settlePayment } from "thirdweb/x402";
import { base } from "thirdweb/chains";
const client = createThirdwebClient({
secretKey: process.env.THIRDWEB_SECRET_KEY!,
});
const twFacilitator = facilitator({
client,
serverWalletAddress: "0xServerWalletAddress",
});
// e.g. Next.js Route Handler or middleware
export async function POST(req: Request) {
const method = request.method.toUpperCase();
const resourceUrl = request.nextUrl.toString();
const paymentData = request.headers.get("X-PAYMENT");
const result = await settlePayment({
resourceUrl,
method,
paymentData,
payTo: "0xTreasuryWalletAddress",
network: base, // chain
price: {
amount: toWei("0.01"), // amount in wei
asset: {
address: "0x0578d8A44db98B23BF096A382e016e29a5Ce0ffe", // ERC-20 address
},
},
});
if (result.ok) {
return new Response(
{ message: "Payment successful" },
{ status: 200 },
);
}
return new Response(result.responseBody, {
status: result.status,
headers: result.responseHeaders,
});
}

Learn more

Happy building!

Manan Tank

The BridgeWidget Script makes it easy to embed cross-chain swaps and fiat onramp UI into your app. Just add a script tag to your HTML and get a fully customizable widget — no build setup required.

BridgeWidget UI

Key Features

  • Cross-chain token swaps across 80+ blockchains
  • Fiat onramp support to buy tokens with credit/debit cards
  • Customizable UI — use prebuilt themes or override with your brand colors
  • Prefill token selections for a smoother user experience
  • Display fiat values in multiple currencies
  • Event callbacks to track user actions (success, error, cancel, disconnect)

Example

<!-- Add this script in <head> -->
<script src="https://unpkg.com/thirdweb/dist/scripts/bridge-widget.js"></script>
<!-- Add a container element where you want to render the UI -->
<div id="bridge-widget-container"></div>
<!-- Initialize the widget at the end of <body> -->
<script>
const container = document.querySelector('#bridge-widget-container');
BridgeWidget.render(container, {
clientId: "your-thirdweb-client-id",
theme: "dark",
});
</script>

Learn More

View Documentation

Joaquim Verges

We've extended the x402 protocol to support passing arbitrary chain ids, and expanded support to 13 new mainnets and 13 new testnets. You can now accept internet-native payments across a total of 35 chains.

In v5.109.0 of the thirdweb SDK, we've introduced new APIs to verify and settle payments and updated our client side API for multichain support.

Here's an example of using settlePayment within a Next.js API route:

// Usage in a Next.js API route
import { settlePayment, facilitator } from "thirdweb/x402";
import { createThirdwebClient } from "thirdweb";
const client = createThirdwebClient({
secretKey: process.env.THIRDWEB_SECRET_KEY,
});
const thirdwebFacilitator = facilitator({
client,
serverWalletAddress: "0x1234567890123456789012345678901234567890",
});
export async function GET(request: Request) {
// verify and settle the payment
const result = await settlePayment({
paymentData: request.headers.get("x-payment"),
resourceUrl: "https://api.example.com/premium-content",
method: "GET",
payTo: "0x1234567890123456789012345678901234567890",
network: "eip155:42161", // CAIP-2 format: "eip155:<chain_id>"
price: "$0.10", // or specific token
facilitator: thirdwebFacilitator,
});
if (result.status === 200) {
// Payment verified and settled successfully
return Response.json({ data: "premium content" });
} else {
// Payment required
return Response.json(result.responseBody, {
status: result.status,
headers: result.responseHeaders,
});
}
}

You can pass any chain id as the network property using the CAIP-2 notation: eip155:<chain_id>. The thirdweb facilitator will handle settling payments on the given chain using the specified token, otherwise defaults to USDC.

Simply call settlePayment in your endpoint handler, middleware or agentic tool to process a payment everytime your API is called.

Here's the list of new chains supported (mainnet + testnet)

  • Arbitrum One
  • Celo
  • Ethereum mainnet
  • HyperEVM
  • Linea
  • Optimism
  • Plume
  • Polygon
  • Sonic
  • Unichain
  • World Chain
  • XDC

Learn more:

Happy building! 🛠️

Manan Tank

We’re launching SwapWidget - a pre-built, customizable UI that lets you easily add a cross-chain token swap UI to your app in just a few lines of code.

Easily integrate into your app

import { SwapWidget } from "thirdweb/react";
import { createThirdwebClient } from "thirdweb";
// 1. Create a thirdweb client
const client = createThirdwebClient({
clientId: "YOUR_CLIENT_ID",
});
// 2. Render widget in your app
function Example() {
return <SwapWidget client={client} />;
}

Try it out

Manan Tank

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

Joaquim Verges

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.

What is x402?

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.

x402 in the thirdweb SDK

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

Client-Side: wrapFetchWithPayment

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

Server-Side: settlePayment

Integrate x402 payments into your endpoints or middleware stack with minimal configuration. Settles payments with your own server wallet, on 170+ chains and with 4000+ tokens

import { createThirdwebClient } from "thirdweb";
import { facilitator, settlePayment } from "thirdweb/x402";
import { arbitrumSepolia } from "thirdweb/chains";
const client = createThirdwebClient({ secretKey: "your-secret-key" });
const thirdwebX402Facilitator = facilitator({
client,
serverWalletAddress: "0xYourWalletAddress",
});
export async function GET(request: Request) {
const paymentData = request.headers.get("x-payment");
const result = await settlePayment({
resourceUrl: "https://api.example.com/premium-content",
method: "GET",
paymentData,
payTo: "0xYourWalletAddress",
network: arbitrumSepolia,
price: "$0.01", // or { amount, asset } for specific token
facilitator: thirdwebX402Facilitator,
});
if (result.status === 200) {
return Response.json({ data: "premium content" });
} else {
return Response.json(result.responseBody, {
status: result.status,
headers: result.responseHeaders,
});
}
}

Get Started


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

Greg

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

Joaquim Verges

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!

Giselle Chacon

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.

How it works

  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

Why it matters

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.

Support that scales with 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. 🚀

Firekeeper

✨ New Features

Bridge API - Chain Discovery Endpoint

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

Bridge API - Fiat-to-Crypto Conversion Endpoint

  • 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

🔄 Changes

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

Visit the full reference here.

Firekeeper

✨ New Features

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

📝 API Changes

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

🔧 Improvements

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

📚 Documentation

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

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.

What thirdweb AI can do for you

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

Other features

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

What about Nebula?

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.

Samina Kabir
Greg

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

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

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.


Why the Split?

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.

What’s Next

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.

Nischit Pradhan

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}

Timeline

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

Impact

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

Alternatives

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

Greg

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

Payments API

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

Firekeeper

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

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" }
}'
Joaquim Verges

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.

Installation

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

Usage with the AI SDK core

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

Usage with the AI SDK UI (React)

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.


Resources

Joaquim Verges

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.


How it works

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.


Authentication

Auto execution requires wallet authentication:

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

Example Request

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

Example Response

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?

Monitoring & Follow-ups

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

Links

Firekeeper

Added

  • 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

Deprecated

  • 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

Migration Guide

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

Benefits of Migration

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

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.

You can now programmatically:
  • 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.

Supported Chains

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


Try it out

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"
}
}'
Manan Tank
Yash Kumar

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!

The new ERC20 token creation flow, you can:
  • 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
Token Distribution configuration UI

How it works

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

Airdrop Tokens

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

Uniswap Liquidity Pool

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).
Mint to your wallet

Any leftover supply is automatically minted to your wallet


Claim Rewards

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

Rewards Page

Supported Chains

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


Try it out

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

Create Coin Page

Firekeeper

What's New

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.

How It Works

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

Key Benefits

  • 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

Use Cases

  • 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

API Endpoints

  • 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

Try it yourself

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

Eiman Abdelmoneim

Overview

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

Quick Reference

First API FieldSecond API FieldNotes
messagemessages[].contentSingle string → Array of message objects
session_idcontext.session_idMoved inside context object (optional)
context (string)context (object)String format → Structured object
walletAddresscontext.fromRenamed field
chainIdscontext.chain_idsRenamed field

Endpoint Changes

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

Request Structure Comparison

Before (Nebula API)

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

After (thirdweb AI Chat API)

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

Migration Steps

1. Update Endpoint URL

Change your base URL from:

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

to:

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

2. Restructure Message Format

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

3. Update Context Structure

Old format (string):

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

New format (object):

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

4. Field Mapping

Old FieldNew FieldRequiredNotes
walletAddresscontext.fromOptionalWallet that executes transactions
chainIdscontext.chain_idsOptionalArray of chain IDs
session_idcontext.session_idOptionalNow nested in context

5. Session Management

  • 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

Example Migration Function

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

Benefits of the New API

  • 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

Testing Your Migration

  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
Joaquim Verges

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


Capabilities

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

Common use cases

  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.

Get started

1) HTTP example

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

2) OpenAI-compatible client (Python)

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)

Response shape

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

Links

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

Greg

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.


Swap 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 Payment

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 →


Execute Payment

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 →

Greg

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.

Firekeeper

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.


One API, Infinite Possibilities

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.


Authentication Made Simple

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.


Web3 Infrastructure at Your Fingertips

  • 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

Game-Changing Features

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.


Build Anything

  • 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

Get Started

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

Yash Kumar

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

What's new?

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

What's been available?

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

Coming Soon

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.

Additional Resources

Support

Need help? Please reach out to our support team.

Manan Tank

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

New Playground home page

What's New

  • 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
Jake Loo

API Changes

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

Deprecated Chains

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

Migration Guide

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

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.

Prithvish Baidya

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

Greg

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.

Prithvish Baidya

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

Greg

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.

Firekeeper

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!

Greg

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.

0:00
/1:16

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.