Changelog

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!