Changelog

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

v1/tokens and v1/nfts endpoints now supports filtering the balances of a wallet by contract addresses.

For tokens, you can add a token_address query filter.

For NFTs, you can use contract_address in the query params.

Both endpoints support multiple contract filters - e.g. ?contract_address=0x...&contract_address=0x...

v1/tokens and v1/nfts endpoints also added support for multiple owner_address query filters so you can get the balances of multiple wallets in the same query!

For example, to get the token balances of both vitalik.eth and barmstrong.eth you can make the following call to Insight

curl 'https://insight.thirdweb.com/v1/tokens?chain=1&metadata=true&include_native=true&limit=5&owner_address=vitalik.eth&owner_address=barmstrong.eth'

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

EIP-7702 execution mode for In-App and Ecosystem Wallets is now available on Berachain Mainnet & Berachain Bepolia!

Berachain: RPC and Chain Settings

Use the best Berachain RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

Berachain Bepolia: RPC and Chain Settings

Use the best Berachain Bepolia RPC and add to your wallet. Discover the chain ID, native token, explorers, and faucet options.

These are the chains we now support, if you'd like us to support more, reach out to support!

• Ethereum (Chain ID: 1)
• Gnosis (Chain ID: 100)
• BNB Smart Chain (BSC) (Chain ID: 56)
• Optimism (Chain ID: 10)
• Base (Chain ID: 8453)
• Ink (Chain ID: 57073)
• Unichain (Chain ID: 130)
• Zora (Chain ID: 7777777)
• Soneium (Chain ID: 1868)
• Mode (Chain ID: 34443)
• Scroll (Chain ID: 534352)
• Arbitrum (Chain ID: 42161)
• Berachain (Chain ID: 80094)

• Sepolia (Ethereum) (Chain ID: 11155111)
• Gnosis Chiado (Chain ID: 10200)
• BSC Testnet (Chain ID: 97)
• Optimism Sepolia (Chain ID: 11155420)
• Base Sepolia (Chain ID: 84532)
• Ink Sepolia (Chain ID: 763373)
• Unichain Sepolia (Chain ID: 1301)
• Zora Sepolia (Chain ID: 999999999)
• Soneium Minato (Chain ID: 1946)
• Mode Sepolia (Chain ID: 919)
• Scroll Sepolia (Chain ID: 534351)
• Arbitrum Sepolia (Chain ID: 421614)
• Berachain Bepolia (Chain ID: 80069)

Engine Cloud exits beta with a complete architectural overhaul powered by our new Rust-based Engine Core. This update introduces simplified APIs, comprehensive transaction monitoring, and significant performance improvements.

Engine Cloud is now built on Engine Core, our new open-source Rust-based blockchain transaction infrastructure. The Engine Core repository is now public.

Key improvements include:

• Sub-second API response times (< 40ms server latency for transactions, < 10ms for status)
• Horizontal scaling through Redis-backed job queues with configurable worker pools
• Memory safety and zero-cost abstractions from Rust
• Improved nonce management and transaction batching
• Enhanced error handling with detailed context

Signature endpoints now use a new signingOptions parameter that replaces the previous executionOptions structure across all signature routes.

Before:

{
  "executionOptions": {
    "from": "0x...",
    "chainId": 137
  }
}

After:

{
  "signingOptions": {
    "type": "eoa",
    "from": "0x...",
    "chainId": 137
  }
}

ERC-4337 Smart Accounts support intelligent defaults with minimal configuration:

{
  "signingOptions": {
    "type": "ERC4337",
    "signerAddress": "0x...",
    "chainId": 137,
    "entrypointVersion": "v0.7"
    // Optional: smartAccountAddress, accountSalt, entrypointAddress, factoryAddress
  }
}

When using thirdweb's default account factory, specifying entrypointVersion automatically configures the appropriate entrypoint and factory addresses:

• v0.6: 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789 (entrypoint), 0x85e23b94e7F5E9cC1fF78BCe78cfb15B81f0DF00 (factory)
• v0.7: 0x0576a174D229E3cFA37253523E645A78A0C91B57 (entrypoint), 0x4bE0ddfebcA9A5A4a617dee4DeCe99E7c862dceb (factory)

The system automatically infers missing values when not explicitly provided, supporting both v0.6 and v0.7 standards.

Response handling is now more intuitive for single fallible operations like signMessage:

Before:

{
  "result": {
    "results": [
      {
        "success": true,
        "data": "0x..."
      },
      {
        "success": false,
        "error": "Invalid signature"
      }
    ]
  }
}

After:

{
  "result": [
    {
      "result": "0x..."
    },
    {
      "error": "Invalid signature"
    }
  ]
}

The new Activity Logs system provides visibility into transaction lifecycle and Engine operations:

• Real-time status tracking from submission to confirmation
• Detailed error context for failed transactions
• Performance metrics including gas usage and timing
• Debug information for troubleshooting

Access via dashboard or API:

GET /transactions/activity-logs?transactionId={queueId}

No breaking changes. Existing ServerWallet implementations continue working—simply upgrade your SDK version:

npm install thirdweb@5.105.2

const serverWallet = Engine.serverWallet({
  address: "0x...", // your wallet address
  chain: sepolia, // or your target chain
  client: thirdwebClient,
  vaultAccessToken: "your_vault_token",
});
 
// All existing methods work identically
const result = await serverWallet.sendTransaction(tx);

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

Engine Cloud is now generally available:

1. Create a thirdweb project
2. Complete Transactions API onboarding to create server wallets and vault access tokens
3. Start making API calls!

Engine Documentation → | API Reference →

• Various improvements and fixes related to session resuming; OAuth, Email and Phone login options should automatically resume much more often, with memory optimizations as well. In practice, this means that after creating your wallet, the IsConnected node will return true much more often, allowing you to skip the user action that typically is required.

Github Release

• Enhanced advanced session key management for compatible wallets, including creation of session keys with granular permissions and policies.
• Added ability to check signer permissions, retrieve session expiration, and inspect session and policy details for signers.
• Expanded data models to represent session states and permission limits for improved session management visibility.
• Enhanced in-code examples and comments to illustrate session key workflows and permission management.

.NET Release | NuGet Release | Unity Release

Documentation | Support

EIP-7702 execution mode for In-App and Ecosystem Wallets is now available on Arbitrum Mainnet!

Arbitrum One: RPC and Chain Settings

Use the best Arbitrum One RPC and add to your wallet. Discover the chain ID, native token, explorers, and more.

These are the chains we now support, if you'd like us to support more, reach out to support!

• Ethereum (Chain ID: 1)
• Gnosis (Chain ID: 100)
• BNB Smart Chain (BSC) (Chain ID: 56)
• Optimism (Chain ID: 10)
• Base (Chain ID: 8453)
• Ink (Chain ID: 57073)
• Unichain (Chain ID: 130)
• Zora (Chain ID: 7777777)
• Soneium (Chain ID: 1868)
• Mode (Chain ID: 34443)
• Scroll (Chain ID: 534352)
• Arbitrum (Chain ID: 42161)

• Sepolia (Ethereum) (Chain ID: 11155111)
• Gnosis Chiado (Chain ID: 10200)
• BSC Testnet (Chain ID: 97)
• Optimism Sepolia (Chain ID: 11155420)
• Base Sepolia (Chain ID: 84532)
• Ink Sepolia (Chain ID: 763373)
• Unichain Sepolia (Chain ID: 1301)
• Zora Sepolia (Chain ID: 999999999)
• Soneium Minato (Chain ID: 1946)
• Mode Sepolia (Chain ID: 919)
• Scroll Sepolia (Chain ID: 534351)
• Arbitrum Sepolia (Chain ID: 421614)

Building on the EIP-7702 Account Abstraction and transaction sponsorship introduced in .NET v2.21.0 and Unity v5.21.0, this release extends Session Key functionality to EIP-7702 Smart EOAs. Session Keys enable granular permission delegation to external wallets for executing transactions on your behalf.

• Permission Delegation: Grant time-limited access to external wallets
• Granular Controls: Define precise execution permissions per session
• Smart EOA Integration: Now available for EIP-7702-powered In-App Wallets, inspired by and improved from Smart Wallet session keys
• Backend Flexibility: Delegate transaction execution to external systems while maintaining control

Create session keys with either full permissions or custom policies:

// Grant full permissions for 24 hours
var sessionKeyReceipt = await smartEoa.CreateSessionKey(
    chainId: chain,
    signerAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
    durationInSeconds: 86400,
    grantFullPermissions: true
);
// Grant custom permissions
var sessionKeyReceipt = await smartEoa.CreateSessionKey(
    chainId: chain,
    signerAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
    durationInSeconds: 86400,
    grantFullPermissions: false,
    callPolicies: new List<CallSpec>(), // Contract interaction rules
    transferPolicies: new List<TransferSpec>() // Value transfer rules
);

const int chain = 11155111; // 7702-compatible chain
// Initialize EIP-7702 wallet
var smartEoa = await InAppWallet.Create(
    client, 
    authProvider: AuthProvider.Guest, 
    executionMode: ExecutionMode.EIP7702Sponsored
);
// Authenticate and upgrade EOA
if (!await smartEoa.IsConnected())
{
    await smartEoa.LoginWithGuest(defaultSessionIdOverride: Guid.NewGuid().ToString());
}
// Execute upgrade transaction (optional)
var receipt = await smartEoa.Transfer(
    chainId: chain, 
    toAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"), 
    weiAmount: 0
);
// Verify account delegation (optional)
var isDelegated = await Utils.IsDelegatedAccount(client, chain, await smartEoa.GetAddress());
// Create session key
var sessionKeyReceipt = await smartEoa.CreateSessionKey(
    chainId: chain, 
    signerAddress: await Utils.GetAddressFromENS(client, "vitalik.eth"),
    durationInSeconds: 86400,
    grantFullPermissions: true
);

Once created, these session keys can be used to:

• Delegate transactions to backend services while maintaining security boundaries
• Enable temporary access for third-party services
• Create specialized roles with limited permissions
• Automate workflows without exposing primary wallet credentials

The session key mechanism opens up numerous possibilities for secure, permissioned delegation patterns while maintaining full control over your assets and contracts.

.NET Release | NuGet Release | Unity Release

Documentation | Support

We've made some exciting improvements to the indexing pipeline of Insight and have managed to reduce the block lag by up to 80%!

What is block lag? - Each block included in the blockchain has a timestamp of when it was constructed. Block lag, in the case of Insight, shows the difference between the block timestamp and when it is queryable via the Insight API.

For example, on Base we were able to the block lag from around 18 seconds on average to around 5 seconds on average.

On Donatuz, we were able to reduce the block lag from an average of 15 seconds to under 2 seconds consistently!

These are just a few examples, but we have applied these optimizations to all the chains Insight supports and we will be continuing work on improving Insight all around.

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

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

You can now filter transfers by the block timestamp, similarly to the previously available block number filter. The following query parameters are now available:

• block_timestamp_from - to query transfers made starting from this timestamp
• block_timestamp_to - to query transfers made until this timestamp

Timestamp format is either a unix timestamp or milliseconds from the epoch.

Another addition is the contract_address query filter, which you can use to only look at transfers for specific tokens or NFT collections.
The endpoints also accept multiple e.g ?contract_address=0x321...&contract_address=0x123...

By default, all transfers are sorted by in a descending order by block number and in an ascending order by the log index (position in the block).

The sort_order query param controls the direction of the block number sort, so you can list the transfers either from oldest or newest.

We've also removed a few query parameters from v1/tokens/transfers that had no effect previously. The parameters were: resolve_metadata_links , sales and the sale option from transfer_type.

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

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

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

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

Here are few examples:

View example page

View example page

View example page

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

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

To access it

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

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

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

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

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

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

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

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

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

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

Live now at nebula.thirdweb.com!

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

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

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

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

Nebula can prepare and execute any transaction across any chain.

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

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

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

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

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

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

Nebula will:

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

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

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

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

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

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

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

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

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

A few more notes:

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

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

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

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

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

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

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

Don't forget to check the docs here!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Insight adds support for filtering NFT transfers by type.

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

transfer - Any transfer without additional sale data

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

mint - A transfer from a zero address

burn - A transfer to a zero address

* Example sale data:

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

Try it out on our playground.

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

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

Nebula v0.0.17 is live now!

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

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

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

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

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

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

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

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

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

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

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

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

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

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