Changelog

We’ve redesigned the contract pages on thirdweb.com/<chain>/<contract-address> to be cleaner, simpler, and more user-friendly — making them perfect for sharing with your community or users.

These pages no longer include contract management features like Setting permissions, Updating settings, Managing claim conditions, Minting tokens etc

Instead, they now focus on: Promoting your primary sales, Showcasing contract analytics, Displaying recent transfers etc

Here are few examples:

View example page

View example page

View example page

All advanced contract management tools are still available — they’ve just moved.

You can now access the full contract admin UI at following URL:
/team/<team>/<project>/contract/<chain>/<contract>

To access it

1. Go to your Team > Project > Contracts tab
2. Find your contract in the table
3. Click the contract row to open its full contract management interface

If the contract isn’t part of your project yet, you’ll need to import it first. Just click “Import Contract” in the top-right of the Contracts page and enter the contract’s address and chain.

We've released three new payments components to cover any use case your onchain app might need. Please note these components are still in beta and their interfaces are subject to change.

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

import { BuyWidget } from "thirdweb/react";
 
function App() {
  return (
    <BuyWidget
      client={client}
      chain={chain}
      tokenAddress="0x..." // Token or NFT contract address
      recipient="0x..." // Optional: recipient address
      theme="light" // Optional: "light" or "dark"
    />
  );
}

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

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

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

import { TransactionWidget } from "thirdweb/react";
import { prepareContractCall } from "thirdweb";
 
function App() {
  const transaction = prepareContractCall({
    contract: myContract,
    method: "transfer",
    params: [recipientAddress, amount],
  });
 
  return (
    <TransactionWidget
      client={client}
      transaction={transaction}
      onSuccess={(result) =>
        console.log("Transaction successful:", result)
      }
      onError={(error) => console.error("Transaction failed:", error)}
      theme="light" // Optional: "light" or "dark"
    />
  );
}

We're excited to announce Nebula v0.1.0, our most comprehensive update yet! This release transforms Nebula into a universal DeFi protocol expert with the ability to execute any contract function across all EVM chains. Whether you're interacting with Uniswap, Aave, or any custom protocol, Nebula now has the knowledge and execution capabilities to handle it all.

Live now at nebula.thirdweb.com!

Nebula now comes equipped with comprehensive knowledge of 50+ major DeFi protocols across all EVM chains. From household names like Uniswap, Aave, and Curve to specialized protocols like Lido, MakerDAO, and Compound - Nebula understands them all.

Our new intelligent research system automatically discovers new protocols, analyzes their contracts, and generates up-to-date documentation for Nebula, to be added periodically. As the DeFi ecosystem evolves, Nebula evolves with it.

Our new enhanced agentic approach now supports arbitrary contract execution with sophisticated parameter handling. Whether you're:

• Swapping tokens on a DEX
• Providing liquidity to a pool
• Staking in a yield farm
• Querying live APY

Nebula can prepare and execute any transaction across any chain.

Nebula is now provided with instant access to cached protocol data, contract addresses, and deployment details. No more waiting for on-chain lookups - Nebula already knows where everything is deployed and how it works.

Behind the scenes, Nebula now automatically generates comprehensive protocol documentation by combining on-chain analysis with web research. This means every interaction is backed by the latest, most accurate information about how protocols actually work.

We've significantly improved Nebula's function calling capabilities with better parameter validation and error handling. The agent now makes fewer mistakes and provides clearer feedback when things go wrong.

• Parallel Image Generation: Visual content now generates concurrently for faster responses
• Specialized Transaction Tools: Split transaction and event aggregation into focused tools for better accuracy
• Enhanced Memory Management: Improved context handling for complex multi-step protocol interactions

Here's how the new capabilities work together. Ask Nebula:

"Provide liquidity to the USDC/ETH pool on Uniswap V3"

Nebula will:

1. Research the current pool parameters and optimal price ranges
2. Prepare any required approvals
3. Prepare the Uniswap V3 liquidity provision transaction

Once successfully executed, Nebula can collect fees, monitor performance, withdraw liquidity or execute any other on-chain interaction.

All of this happens seamlessly across protocols, with Nebula understanding the nuances of each platform.

• Advanced Web Search: Better protocol-specific query handling and result filtering, for information that isn't already cached by Nebula
• Cross-Chain Compatibility: Enhanced support for protocol interactions across different EVM chains
• Improved Error Handling: More informative error messages and recovery suggestions
• Better Transaction Aggregation: More accurate grouping and analysis of related transactions

With this foundation of universal protocol knowledge and arbitrary contract execution, we're laying the groundwork for even more powerful DeFi automation and strategy execution. Stay tuned for exciting developments in the coming releases!

Ready to explore the full potential of DeFi with Nebula v0.1.0? Try asking about your favorite protocol - chances are, Nebula already knows all about it.

Until now, token prices in Insight were only available through dedicated /price endpoints — useful, but disconnected from the broader token experience.

Starting today, latest price data is embedded directly into all routes that can return fungible token metadata — including /v1/tokens/balances & v1/tokens/transfers with metadata flag set to true . That means you’ll now see up-to-date pricing info (like price_usd, percent_change_24h, volume_24h_usd, and more) inline with your token balances and other metadata-rich responses.

This change makes it drastically easier to surface value and context in a single call — whether you're showing wallet assets, building dashboards, or triggering logic based on price.

A few more notes:

• This works for both ERC-20 and native tokens.
• Currently this is powered by the offchain aggregated price feeds, but we'll work expending the strategies further.
• Some niche tokens might not have price data (yet) — but future updates will improve coverage and enable better filtering of spammy or scammy assets based on this info.

Price data just got a lot more accessible — and this is only the beginning!

Let us know what you think!
We're always looking to improve how we serve token data — if you're using this in your app, tooling, or analytics pipeline and have thoughts, feature requests, or sharp criticism: we want to hear it. Just drop us a line in Discord or open a discussion on GitHub.

Users can now track fungible and non-fungible token transfers more reliably — even when the same event signature (like Transfer) is used across multiple token standards.

• 🔄 Multi-ABI Decoding: Webhooks now support decoding the same event signature using multiple ABIs. This is especially useful for events like Transfer that appear in both ERC-20 and ERC-721 contracts with different parameter structures.
• 💥 Fallback Decoding: If the first ABI fails to decode the event, we now try all provided ABIs until one succeeds — making decoding more robust.
• 🧪 Better Decoding for Edge Cases: For example, events with empty data fields ("0x") are now handled gracefully, and error handling during decoding has been improved.

We also updated the docs to help developers integrate with AI agents or build smart event-driven systems:

• Clearer instructions on setting up and managing webhooks via the Insight API
• New examples of multi-ABI event filters, including how to handle both ERC-20 and ERC-721 Transfer events
• Payload structure explained in more depth for downstream agent consumption

Don't forget to check the docs here!

Many token standards reuse the same event signature hash (Transfer(address,address,uint256)), but the meaning and structure can differ. This update makes sure your webhook will correctly decode whichever version it encounters.

📌 Note: This feature is currently available via API only — improved UI/UX support for creating and managing multi-ABI filters is on the roadmap!

Let us know if you need help setting up multi-ABI filters for your use case — or if there’s another event format we should support next.

We've integrated EIP-1271 and EIP-6492 Smart Wallet signing into the UE SDK so you can verify auth seamlessly from your backend without having to deploy your smart wallets.

No changes to your code are required, simply upgrade to the latest SDK, and your signatures will now match what most authentication systems expect from smart wallets.

This is now at parity with our other SDKs (TS, React, .NET, Unity, etc.)

Github Release | Fab Marketplace
2.1.1 will be available on Fab around 6/14/2025

We’re thrilled to announce a powerful new addition to our RPC toolkit: native WebSocket support for Plume Mainnet (chain ID 98866) and Testnet (chain ID 98867). Now you can subscribe to live block events and react instantly as new blocks are produced—no polling required

• WebSocket Endpoints
  • Mainnet:
    wss://98866.rpc.thirdweb.com/ws/<client_id>
  • Testnet
    wss://98867.rpc.thirdweb.com/ws/<client_id>
    
• Real-Time Block Events
  Subscribe once and receive a continuous stream of block headers and payloads as they’re finalized on-chain.

1. Instant Data
   No more waiting for HTTP responses—get block notifications the moment they happen.
2. Lower Latency
   Maintain a persistent socket connection instead of hammering REST endpoints.
3. Scalability
   Stream to multiple clients or services without spinning up extra request handlers.

1. Generate or retrieve your <client_id> from your Thirdweb dashboard.
2. Connect via your favorite WebSocket library:

import WebSocket from "ws";
 
const chainId = "98866"; // or "98867" for Testnet
const clientId = "<your_client_id>";
const wsUrl = `wss://${chainId}.rpc.thirdweb.com/ws/${clientId}`;
 
const ws = new WebSocket(wsUrl);
 
ws.on("open", () => {
  console.log("Connected to Plume WebSocket!");
  // Subscribe to new block events
  ws.send(
    JSON.stringify({
      id: 1,
      jsonrpc: "2.0",
      method: "eth_subscribe",
      params: ["newHeads"],
    }),
  );
});
 
ws.on("message", (data) => {
  const event = JSON.parse(data);
  console.log("New block received:", event);
});

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

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

You can now create new teams from the thirdweb dashboard. This feature allows you to create multiple teams to separate team members and projects effectively.

Why use teams? Use different teams to organize separate apps or clients, each with their own assets, team members, usage analytics, and billing. Creating teams is free, and each team has its own subscriptions and team-specific limits.

Visit the My Account page or use the team selector in the top navigation, then select "Create Team".

Switch between teams: Use the team selector to move between your teams.

Transfer a team: Simply add another owner to the team, and remove the original owner.

Example: Owner A owns team A but wants to transfer it to owner B. After owner A invites owner B to the team, owner B can remove owner A.

Delete a team: No longer need a team? Delete it from the Settings > General page.

Manage who can view and update your thirdweb resources by adding team members from the Settings > Members page.

Visit the Pricing page to learn more about plans that include multiple seats.

Insight adds support for filtering NFT transfers by type.

On the v1/nfts/transfers endpoint you can specify a transfer_type query parameter and choose to filter transfer, sale, mint or burn transfers.

transfer - Any transfer without additional sale data

sale - A transfer that has additional sale data* (Seaport protocol supported)

mint - A transfer from a zero address

burn - A transfer to a zero address

* Example sale data:

"transaction_hash": "0x6bb2c31fd42a504b375c94441693effced0c1ff41b4e8d3d8396eeed9cd55bb8",
"items_sold": [
  {
    "token_address": "0x413530a7beb9ff6c44e9e6c9001c93b785420c32",
    "token_id": "1881",
    "amount": "1",
    "from_address": "0x055e4e77cbc70c59bef7f42c5603a7d77a82ca0c",
    "token_type": "erc721"
  }
],
"payment": [
  {
    "token_address": "0x0000000000000000000000000000000000000000",
    "token_id": "0",
    "amount": "6965000000000000",
    "token_type": "",
    "to_address": "0x055e4e77cbc70c59bef7f42c5603a7d77a82ca0c"
  },
  {
    "token_address": "0x0000000000000000000000000000000000000000",
    "token_id": "0",
    "amount": "35000000000000",
    "token_type": "",
    "to_address": "0x0000a26b00c1f0df003000390027140000faa719"
  }
],
"marketplace_address": "0x0000000000000068f116a894984e2db1123eb395",
"marketplace_name": "opensea"

Try it out on our playground.

📖 Learn more about Insight - it’s open source and ready to power your applications!

This release introduces significant improvements to Nebula's agent capabilities, adding fiat onramping through Universal Bridge, new NFT collection tools, and aggregated transaction and events data. Improvements have been made to Nebula’s memory handling, leading to faster responses in some cases and helping us prepare for our next major release. Additionally, we fixed a major bug that caused Nebula to respond with "No response received, please try again" in long-running queries.

Nebula v0.0.17 is live now!

• Added an onramping tool for fiat-to-crypto transactions using thirdweb Universal Bridge
• Improved token swap preparation for better cross-chain support and tool-calling accuracy
• Expanded the capabilities of transaction and event aggregation

• Nebula can now retrieve on-chain NFT collection statistics
• Added NFT token retrieval for token-specific data like URI metadata
• Enhanced transaction and event aggregation for significantly improved accuracy

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

• Nebula now tracks deployed and referenced contracts, preserving them in session memory
• Improved agent autonomy through better tool chaining and context retention

Aggregations are an exciting addition to Nebula's capabilities, enabling complex queries such as:

User: Find the top 5 contracts on Base in the past hour by transaction count

Nebula: Here are the top 5 contracts on Base by transaction count in the past hour (from 2025-06-05 11:15:19 UTC to now):

1. 0xfe16e9fcc577cb9b19319f6c97d915d58545fd7f — Name: UnknownContract, Transactions: 18,324
2. 0x00f79a40ffa54316059614c280750756412a5fc9 — Name: UnknownContract, Transactions: 14,138
3. 0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24 — Name: UniswapV2Router02, Transactions: 14,021
4. 0x1307b5f4f528519b3ad44c98cdf4e156686c6f63 — Name: UnknownContract, Transactions: 12,413
5. 0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad — Name: UniversalRouter, Transactions: 12,167

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

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

• Improved contract deployment tools with enhanced flexibility
• Better address checksumming and output type validation
• Enhanced transaction preparation with native token support
• Fixed tools to properly handle base units and native tokens

• Fixed an issue where parts of responses were cut off
• Resolved duplicate answers in agent responses
• Improved contract function parameter validation
• Fixed multiple type-related issues across tools
• Improved parameter validation for contract deployments

This release marks a significant step forward in Nebula's capabilities, delivering more reliable tools, smarter agents, and expanded financial integrations for building full-featured blockchain applications.

You can now set up webhooks directly in your dashboard to track blockchain activity in real-time—no more polling, no more missing important events.

Webhooks allow you to:

• Get notified when specific events happen on-chain (like NFT mints, transfers, or contract calls) or any contract function you specify
• Automate downstream processes like updating your app, sending emails, or triggering workflows
• Stay in sync with blockchain state—even when there are re-orgs (yup, we handle that too)

Get started with webhooks by creating a project > Webhooks > Create Webhook

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

Picking EIP-7702 as the smart wallet execution mode for your ecosystem has multiple benefits:

• your users will be able to use the same smart account features as EIP-4337 like gas sponsorship, batching and session keys
• Smart account address will be the same address as their EOA address.
• Execution speed will be up to 3x faster than EIP-4337 userOps.
• No code change required

Keep in mind that this standard only works on chains that have adopted the EVM pectra update. Most popular chains support it today, with more chains adopting it every week.

We recommend trying out 7702 execution for your ecosystem wallets, just enable the setting in your dashboard and connect to your ecosystem wallets to take advantage of this new smart account standard.

Happy building! 🛠️

We've improved our wallet service for in-app and ecosystem wallets with new quality of life features. Below are the highlights and detailed changes.

• Account deletion flag – allow end‑users to erase their wallet account entirely when unlinking the final auth profile.
• Improved partner attribution – new user records created via an ecosystem partner are now tagged, and filtering is supported via the API.
• Phone‑login sandboxing – deterministic phone/O​TP pair for local development and App Store / Play Store review flows.

Apple and other platforms mandates an way to delete user accounts.
You can now fulfill this requirement by setting allowAccountDeletion: true when unlinking the final profile tied to a wallet.

import { useUnlinkProfile } from "thirdweb/react";
 
const { mutate: unlinkProfile } = useUnlinkProfile();
 
const handleUnlink = () => {
  unlinkProfile({
    client,
    profileToUnlink: connectedProfiles[0],
    allowAccountDeletion: true, // Deletes the account if it's the last profile
  });
};

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

• Automatic tagging – Any new wallet created through an ecosystem partner is now associated with that partner ID. (Existing users remain unchanged.)
• Filtering – Query only the users for a given partner by providing both headers:

x-ecosystem-id:          <your‑ecosystem‑id>
x-ecosystem-partner-id:  <partner‑id>

GET /v1/users now returns only the wallets originated by that partner when both headers are present.

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

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

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

© 2025 Thirdweb

v5.102.0 of the thirdweb TypeScript SDK rolls out server-side wallet orchestration and better transaction management—adding APIs to create & list server wallets, search transactions with flexible filters, batch multiple calls in one shot, and clearer error reporting.

Create a new server wallet with a custom label.

import { Engine } from "thirdweb";
 
const serverWallet = await Engine.createServerWallet({
  client,
  label: "My Server Wallet",
});
console.log(serverWallet.address);
console.log(serverWallet.smartAccountAddress);

List every server wallet that already exists.

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

Search transactions by ID, chain ID, sender, and more (supports nested AND/OR filters).

// By transaction IDs
const transactions = await Engine.searchTransactions({
  client,
  filters: [{ field: "id", values: ["1", "2", "3"] }],
});
 
// By sender and chain
const transactions = await Engine.searchTransactions({
  client,
  filters: [
    {
      filters: [
        {
          field: "from",
          values: ["0x1234567890123456789012345678901234567890"],
        },
        { field: "chainId", values: ["8453"] },
      ],
      operation: "AND",
    },
  ],
  pageSize: 100,
  page: 0,
});

Queue multiple transactions in a single batch and wait for completion.

// Prepare transactions
const tx1 = claimTo({ contract, to: firstRecipient, quantity: 1n });
const tx2 = claimTo({ contract, to: secondRecipient, quantity: 1n });
 
// Enqueue batch
const { transactionId } = await serverWallet.enqueueBatchTransaction({
  transactions: [tx1, tx2],
});
 
// Wait for the batch to finish
const { transactionHash } = await Engine.waitForTransactionHash({
  client,
  transactionId,
});
console.log(transactionHash);

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

We’ve just shipped a powerful new feature to the Insight dashboard: Webhooks.

This release makes it easier than ever for developers to listen to blockchain events and transactions in real time — and trigger actions when they matter most.

Whether you’re building dashboards, automation workflows, or real-time alerts, Webhooks give you the tools to keep your system tightly synced with on-chain activity.

Webhooks let you subscribe to blockchain activity and receive notifications when specific events or transactions occur — directly to your own application.

They’re ideal for:

• Tracking contract events (e.g. transfers, mints, executions)
• Monitoring transactions
• Building alerting and analytics pipelines
• Powering downstream workflows from blockchain data

Events are delivered in batches, with at-least-once delivery and unique event IDs for easy deduplication. We recommend using a queue system if your processing is heavy.

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

• Create Webhooks
• Filter by Contract, Event Signature, or Function Selector
• Automatic ABI fetching to enable decoded data at delivery
• Test Mode to verify endpoints before going live
• List & Delete existing webhooks with full error and loading states

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

• Aggregate Parameter Input v2
  • Brand-new component for aggregate parameters input.
  • Pop-over UI with search, check-boxes, and live badges so you can combine multiple presets in one click.
  • Works anywhere aggregate is supported – Blocks, Transactions, Events, Wallet Transactions.
• Preset library out of the box
  • ✨ Transaction Count, Total Value, Avg Value, Total Fees … plus contextual sets for each endpoint.
  • Custom SQL-like snippets still welcome—type them right alongside the presets.
• Smarter parameter section
  • Descriptions & examples now auto-swap based on the parameter name for clearer guidance.
  • Place-holders use the parameter’s real description if one exists.

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

• Replaced the plain old input field with a polished multifunctional pop-over.
• State sync so manual edits and preset picks never collide.
• Cleaner tooltip positioning and internal refactor of ParameterSection.

Enjoy faster insights without memorising SQL! Let us know what you build.

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

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

Try it out on our playground.

The two endpoints to query NFT owners (v1/nfts/owners/:contract_address and /v1/nfts/owners/:contract_address/:token_id ) now have the ability to return the balance of each owner in addition to owner addresses.

To enable it, use the query param include_balances=true when calling the endpoints. This will change the response format, so make sure it will not break your app!

The new response format will be an array of owner objects, for example:

{
    "data": [
        {
            "chain_id": 1,
            "token_address": "0x5bb3d01f32687f92f8636799687e55cba0627704",
            "owner_address": "0x0000000000000000000000000000000000000001",
            "token_id": "88",
            "balance": "1"
        },
        ...
    ]
}

📖 Learn more about Insight - it’s open source and ready to power your applications!

This release introduces new integrations to expand both thirdweb AI and thirdweb MCP capabilities with Google's Agent Development Kit (ADK), and adds support for thirdweb Engine Cloud, allowing for autonomous on-chain interactions.

• Added Google Agent Development Kit (ADK) adapter support
• Enables direct integration with thirdweb tools for use with ADK agents
• Supports all thirdweb AI tools and thirdweb MCP

from google.adk.agents import Agent
from thirdweb_ai import Insight
from thirdweb_ai.adapters.google_adk import get_google_adk_tools
 
# Initialize Insight with secret key
insight = Insight(secret_key=secret_key, chain_id=1)
insight_tools = insight.get_tools()
 
# Convert to Google ADK tools
adk_tools = get_google_adk_tools(insight_tools)
 
# Create the agent with the tools
agent = Agent(
    model="gemini-2.0-flash",
    name="thirdweb_insight_agent",
    tools=adk_tools,
)

• Introduced dedicated Engine Cloud service integration
• Supported in all AI integrations, and the thirdweb MCP server
• Allows for autonomous on-chain executions like creating engine cloud wallets, and transacting on-chain

from thirdweb_ai import EngineCloud
 
# Initialize EngineCloud with credentials
engine_cloud = EngineCloud(
    secret_key="your_secret_key",
    vault_access_token="your_vault_token"
)
 
# Get cloud-based engine tools for AI integrations
tools = engine_cloud.get_tools()

To run engine cloud within thirdweb MCP you must provide a vault_access_token:

THIRDWEB_SECRET_KEY=... \
    uvx thirdweb-mcp --vault-access-token=...

This gives you access to Engine Cloud tools like creating wallets, or sending transactions.

thirdweb-ai and thirdweb-mcp v0.1.24 are both live now on PyPi!

Insight API adds a new token balances endpoint that also supports native token balances. It will replace the current ERC-20 balance endpoint which is being deprecated.

This endpoint is being deprecated in favor of v1/tokens to be better aligned with the NFT endpoints and make it easier to expand the capabilities of the new endpoint in the future.

v1/tokens has full parity with the ERC-20 balances endpoint but also adds support for native token balances and also returns the owner_address in the response.

Native balances are always returned at the beginning of the response. If they are not needed, they can be removed from the response by setting the include_native query param to false.

The native token address is 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

The new endpoint is available in our playground.

📖 Learn more about Insight - it’s open source and ready to power your applications!

We’ve improved the Insight API to support unified access to all token transfers — both NFTs (ERC721/ERC1155) and fungible tokens (ERC20) — through a single, consistent endpoint 🚀

• You can now fetch NFT and ERC20 transfers in one call.
• Transfer responses include metadata for both NFTs and ERC20 tokens.
• Added support for a new "burn" transfer type when tokens are sent to the zero address.
• Introduced filtering by token type (erc20, erc721, erc1155) via query parameters.

This change simplifies integration and improves performance when querying mixed token transfers — especially useful for clients who need a single endpoint to track all token activity.