Changelog

Effective Date: March 3, 2025, at 12:00 PM PST

Announcing some important changes to our mint fee process that further standardize our fee structure for all new contract deployments. We are introducing a 1% protocol fee applied to all contracts, and adjusting the convenience fee to 1.5% from previous 2.5%.

We believe this change strikes the right balance between a standardized protocol fee and the flexibility for custom fee settings, making fee management easier and more transparent for everyone.

Please note this change does not effect already deployed contracts.

• Fixed protocol fee:
  All new deployments now include a non-overridable 1% protocol fee. This fee is implemented into the contract and will always apply if deployed through SDK, dashboard, or third-party integrations. For example, an asset listed at 0.1 ETH will distribute 0.099 ETH to the seller and 0.001 ETH to the platform.
• Convenience Fee:
  When deploying via dashboard, the fee includes a 1.5% convenience fee or 2.5% total (1% protocol fee plus an additional 1.5%). For example, an asset listed at 0.1 ETH will distribute 0.0975 ETH to the seller and 0.0025 ETH to the platform.
• Custom Fee Configuration:
  You can still set your own platform fee during deployment or later via our platform. The process works exactly as before, with the custom fee now being applied in addition to the fixed thirdweb fee.

This adjustment helps support continued development and maintenance of prebuilt smart contracts, ensuring reliability, security, and innovation for the ecosystem.

For any questions or further details, please reach out to our support team.

• Which prebuilt contracts will have included fees?
  • The following contracts and corresponding modular versions will now include a seller fee:
    • Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
    • Token Contracts: TokenERC20, TokenERC721, TokenERC1155
    • Specialized Contracts: LoyaltyCard, BurnToClaim, MarketplaceV3
• I deployed a contract prior to the effective date, will these fees apply to me?
  • This fee is only applied to any contracts deployed after 12 pm PST on March 3, 2025

We Introduced a new include_spam query parameter to the ERC20 token endpoint to filter out potential spam tokens.

GET /v1/tokens/erc20/vitalik.eth&include_spam=true

The criteria for identifying spam include:

• Empty token name

• Empty token symbol

• Symbol length greater than 15 characters

• Zero decimals

By default, spam tokens are excluded from responses (include_spam=false). You can try it in our playground by visiting here. See the example bellow:

Here is a Typescript example showing how to use it in your code:

fetchTokens = async () => {
  try {
    const response = await fetch(
      "https://1.insight.thirdweb.com/v1/tokens/erc20/vitalik.eth?metadata=true&include_spam=true",
      {
        headers: {
          "x-client-id": clientId,
        },
      },
    );
    const tokensResult = await response.json();
    return tokensResult;
  } catch (error) {
    console.error("Error:", error);
  }
};

We are now supporting NFT metadata for Insight NFT balance endpoints (ERC-721 and ERC-115).

By adding metadata=true query parameter to the request, the response will include metadata about the NFT - name, description, image URL, background color, external URL, collection and contract info in addition to the balance.

Here's an example of the data that can be returned:

{
  "chainId": 137,
  "tokenAddress": "0x819384ee58c4aadcf170a78728addafb6301d871",
  "tokenId": "3907",
  "balance": "1",
  "name": "Cloude Doodle #3907",
  "description": "The Doodle Cloud Kingdom is an ally of the Bekantan Kingdom to defend and show strength.",
  "image_url": "ipfs://QmVCu8NRuKUb64jDQqg3fsPrXa19W37Y7Cx2Vo8C5fdZe5/3907.png",
  "extra_metadata": {
    "dna": "20a571eaae29e115ed30716bf4282f7663ab3f7c",
    "edition": 3907,
    "date": 1660320491602,
    "attributes": [
      {
        "trait_type": "Background",
        "value": "Gradient (55)"
      },
      {
        "trait_type": "Body",
        "value": "Cumulos (61)"
      },
      {
        "trait_type": "Hat",
        "value": "Bando (7)"
      },
      {
        "trait_type": "Mouth",
        "value": "Stoic"
      },
      {
        "trait_type": "Eyes",
        "value": "Villain"
      },
      {
        "trait_type": "Nose",
        "value": "Disgusted (57)"
      }
    ],
    "compiler": "HashLips Art Engine"
  },
  "collection": {
    "name": "Cloude Doodle"
  },
  "contract": {
    "type": "ERC721",
    "name": "Cloude Doodle",
    "symbol": "CLD"
  }
}

Try it out on our playground

Or call it directly from code

const getNFTsWithMetadata = async (address: string) => {
  try {
    const response = await fetch(
      `https://1.insight.thirdweb.com/v1/tokens/erc721/${address}?metadata=true`,
      {
        headers: {
          "x-client-id": <your-client-id>,
        },
      },
    );
    const response = await response.json();
    return response;
  } catch (error) {
    console.error("Error:", error);
  }
};

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

The Insights API now supports querying contract metadata and ABIs. Powered by our contract indexing and verification backend, developers can now access verified contract metadata and ABIs for all supported chains directly within Insights. This eliminates the need to interact with block explorers and third party source code verifiers to get contract metadata and ABIs.

We've added the following endpoints:

curl https://insight.thirdweb.com/v1/contracts/abi/0x66a9893cc07d91d95644aedd05d03f95e1dba8af?chain=1&clientId=THIRDWEB_CLIENT_ID

curl https://insight.thirdweb.com/v1/contracts/metadata/0x66a9893cc07d91d95644aedd05d03f95e1dba8af?chain=1&clientId=THIRDWEB_CLIENT_ID

Both endpoints are available in the playground to test.

Stay tuned for more updates and exciting features from Thirdweb!

We’re excited to unveil a powerful addition to the thirdweb platform: a brand-new API designed to automate chain onboarding in real time. This release is especially useful for Rollup-as-a-Service (RaaS) providers, who can now seamlessly integrate new chains into the thirdweb ecosystem the moment they’re spun up. No more back-and-forth or manual listing processes—this API provides a streamlined way to manage your chains on thirdweb.

1. Automated Registration of Newly Spun-Up Chains
   Our new API endpoints let you programmatically add or update chain configurations on the thirdweb platform. This is critical for RaaS providers who rapidly deploy new chains and need an immediate, frictionless connection to thirdweb.
2. Seamless Integration with Existing Workflows
   Because the API is designed for simplicity, it easily slots into your existing DevOps workflow. You can add a single API call to your chain deployment scripts, automatically informing thirdweb about the new chain’s details—no manual steps required.
3. Real-Time Updates
   Once your chain is registered, the thirdweb platform reflects the changes immediately, so developers can start using thirdweb tools (SDKs, CLIs, and dashboards) on your newly created chains right away.
4. Robust Documentation and Tooling
   We’ve launched an accompanying API Reference that covers everything you need—from authenticating requests to building complex integration flows. You’ll find clear examples, success and error response codes, and best practice guidelines.

Below are some of the most commonly used endpoints. A full list of endpoints and usage examples can be found in the API docs.

• POST /chains
  Register a new chain with thirdweb. Supply essential metadata (e.g., chain name, chain ID, explorer URLs, stack type and custom RPC urls) for immediate onboarding.
• GET /chains
  Fetch details about chains added by your team. Useful for verifying that your chains has been successfully added and has all the relevant info present.
• PUT /rpcUrls/{chainId}
  Add RPC urls for an existing chain, very requested by RaaS providers.

• Speedy Deployment: Spin up a new rollup chain and instantly register it with thirdweb in a single automated step.
• Less Overhead: No more waiting on manual reviews or dealing with miscommunications. Your chain data stays in sync whenever you roll out a new version or fork.
• Scalability: Whether you have one chain or a thousand, the API is built to handle bulk provisioning and updates.

1. Review the Documentation
   Check out the API docs for quickstart guides and detailed references.
2. Generate an API Key
   Obtain an API key from your thirdweb dashboard. This key will authenticate your requests.
3. Integrate With Your Deployment Scripts
   Add API calls to your RaaS deployment pipeline or CI/CD workflow to register new chains automatically.
4. Test & Monitor
   Use the provided sandbox environment or your standard staging area to test new chain registrations before rolling out changes to production.

We’re committed to making thirdweb the most developer-friendly platform for emerging blockchain solutions. Here’s a sneak peek at what’s coming next:

• Account Abstraction
  Automate provisioning and integration with your custom account abstraction flows for enhanced security and better user experiences.
• Universal Bridge (previously thirdweb Pay)
  Simplify asset transfers across different chains with an automatically provisioned, interoperable payment/bridge layer.
• Insight
  Gain real-time analytics and diagnostics across all your chains—insightful dashboards and metrics will be automatically enabled for new rollups.

Expect these features—along with additional endpoints, analytics hooks, and security enhancements—to be part of our continued effort to streamline multi-chain support.

Stay tuned for details and in the meantime, don't hesitate reaching out to get early access and needed permissions to be able to utilise this and give us feedback!

As always, thank you for building with thirdweb!

We’re introducing metadata retrieval in our ERC20 token API!

You can now include token information—such as name, symbol, and decimals—in a single call to our /tokens/erc20 endpoint. Just add the new metadata=true parameter to the query string. For example:

GET /v1/tokens/erc20/vitalik.eth&metadata=true

This returns the token’s metadata along with the usual balance data, simplifying your workflows and saving you from making extra calls. We’ve also added caching so metadata lookups are faster after the first request.

You can try it in our playground by visiting here. See the example bellow:

Here is a Typescript example showing how to use it in your code:

const search = async () => {
 try {
   const response = await fetch('https://1.insight.thirdweb.com/v1/tokens/erc20/vitalik.eth?metadata=true', {
      headers: {
        "x-client-id": clientId,
      },
    });
   const tokensResult = await response.json();
   return tokensResult
 } catch (error) {
   console.error('Error:', error);
 }
};

Insight API added support for querying block data.

Try it out on our playground

Or use it directly from code

const getBlock = async (blockNumber: number) => {
  try {
    const response = await fetch(
      `https://1.insight.thirdweb.com/v1/blocks?filter_block_number=${blockNumber}&limit=1`,
      {
        headers: {
          "x-client-id": <your-client-id>,
        },
      },
    );
    const blockResponse = await response.json();
    return blockResponse.data[0];
  } catch (error) {
    console.error("Error:", error);
  }
};

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

Insight API now supports an explorer-like endpoint to resolve blockchain data.

The resolve endpoint supports

• Transaction hashes - returns the transaction data
• Block hashes - returns the block data
• Addresses (also ENS names)
  • In case of an EOA - returns last 20 transactions from that address
  • In case of a contract - returns last 20 transactions to that address
• Event signatures - returns the latest 20 events with the given signature
• Function signatures - returns the latest 20 transactions with the given signature

Try it out on our playground

Or use it directly from code

const resolve = async () => {
 try {
   const response = await fetch('https://1.insight.thirdweb.com/v1/resolve/0xe01d4a0dbd117152f14c081a8b91b4f55429c469e2dc1530ea00d2714c6bb2a8', {
      headers: {
        "x-client-id": clientId,
      },
    });
   const result = await response.json();
   return result
 } catch (error) {
   console.error('Error:', error);
 }
};

This endpoint was initially called v1/search/:input but was changed to v1/resolve/:input to better reflect its purpose.

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

At thirdweb, innovation is in our DNA. We’re excited to share a behind-the-scenes look at how our team is continuously pushing the boundaries to deliver an unparalleled user experience. Today, we're diving into some key upgrades that have transformed our RPC server.

We’ve made a bold move by switching our RPC server to the Bun runtime. This isn’t just a technological upgrade—it’s a leap toward efficiency. With this change, we’ve managed to slash memory usage by 30%. What does that mean for you? More network requests are handled seamlessly, ensuring a smoother and more responsive experience without the need for extra hardware.

Performance matters, and every millisecond counts. By introducing short-term caching into our architecture, we’ve dramatically reduced latency. Our metrics tell the story:

• P90 latency is down by 50%.
• P95 latency has improved by a whopping 300%.

These numbers translate into faster response times and a more robust service, even during peak usage periods.

Understanding every nuance of our system is key to delivering excellence. We’ve integrated fine-grained our Performance Monitoring that drills down into every RPC call. This means we now track method-level usage and latency, giving us a crystal-clear view of performance across the board. With this insight, we’re empowered to act swiftly, optimizing our service before issues can arise.

Insight is an extremely useful and performant tool to query blockchain data and can decorate it quite nicely too.

Did you know that vitalik, on Ethereum, Polygon and Arbitrum alone owns 7811 ERC20s, 34,362 ERC721s and 2,818 ERC1155s?
Let's go through some examples!

Instantiation

using Thirdweb.Indexer;
// Create a ThirdwebInsight instance
var insight = await ThirdwebInsight.Create(client);

Simple Args

// Setup some filters
var address = await Utils.GetAddressFromENS(client, "vitalik.eth");
var chains = new BigInteger[] { 1, 137, 42161 };

Fetching all tokens owned by a given address

// Fetch all token types
var tokens = await insight.GetTokens(address, chains);
Console.WriteLine($"ERC20 Count: {tokens.erc20Tokens.Length} | ERC721 Count: {tokens.erc721Tokens.Length} | ERC1155 Count: {tokens.erc1155Tokens.Length}");

Fetching a specific type of token owned by a given address

// Fetch ERC20s only
var erc20Tokens = await insight.GetTokens_ERC20(address, chains);
Console.WriteLine($"ERC20 Tokens: {JsonConvert.SerializeObject(erc20Tokens, Formatting.Indented)}");
// Fetch ERC721s only
var erc721Tokens = await insight.GetTokens_ERC721(address, chains);
Console.WriteLine($"ERC721 Tokens: {JsonConvert.SerializeObject(erc721Tokens, Formatting.Indented)}");
// Fetch ERC1155s only
var erc1155Tokens = await insight.GetTokens_ERC1155(address, chains);
Console.WriteLine($"ERC1155 Tokens: {JsonConvert.SerializeObject(erc1155Tokens, Formatting.Indented)}");

Fetching Events
Note: most of these parameters are optional (and some are not showcased here)

// Fetch events (great amount of optional filters available)
var events = await insight.GetEvents(
    chainIds: new BigInteger[] { 1 }, // ethereum
    contractAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", // bored apes
    eventSignature: "Transfer(address,address,uint256)", // transfer event
    fromTimestamp: Utils.GetUnixTimeStampNow() - 3600, // last hour
    sortBy: SortBy.TransactionIndex, // block number, block timestamp or transaction index
    sortOrder: SortOrder.Desc, // latest first
    limit: 5 // last 5 transfers
);
Console.WriteLine($"Events: {JsonConvert.SerializeObject(events, Formatting.Indented)}");

Full Insight .NET Reference

Engine is one of thirdweb's most important products. We've created an EngineWallet class that can be used as an IThirdwebWallet and as such benefits from being compatible with the entire SDK!

Usage:

// EngineWallet is compatible with IThirdwebWallet and can be used with any SDK method/extension
var engineWallet = await EngineWallet.Create(
    client: client,
    engineUrl: Environment.GetEnvironmentVariable("ENGINE_URL"),
    authToken: Environment.GetEnvironmentVariable("ENGINE_ACCESS_TOKEN"),
    walletAddress: Environment.GetEnvironmentVariable("ENGINE_BACKEND_WALLET_ADDRESS"),
    timeoutSeconds: null, // no timeout
    additionalHeaders: null // can set things like x-account-address if using basic session keys
);
// Simple self transfer
var receipt = await engineWallet.Transfer(chainId: 11155111, toAddress: await engineWallet.GetAddress(), weiAmount: 0);
Console.WriteLine($"Receipt: {receipt}");

Integrated with last December's EIP-7702 release!

• Arbitrum, Arbitrum Nova and Arbitrum Sepolia gas price related methods now get shortcut early and return maxFeePerGas = maxPriorityFeePerGas = current gas price.
• Utils.GetChainMetadata chain id related variables updated from int to BigInteger.

.NET Release | NuGet Release | Unity Release

Documentation | Support

Collaborating with your team just got easier! You can now invite new members and manage existing ones directly from your dashboard.

This feature is available to all "Starter", "Growth" and "Pro" plan customers today.

• Invite single or multiple team members via email
• Assign roles during the invitation process 

• View all team members and their assigned roles.
• Remove team members when needed
• Search, filter, and sort team members for easy management

• Track all pending and expired invites
• Delete an invite to revoke the invitation before it is accepted

Go to thirdweb dashboard > Your Team > Settings > Members page

Insight API now supports Ethereum Name Service (ENS) names in address fields. You can use ENS names instead of raw Ethereum addresses when querying API endpoints.

Try it out on our playground

Or use it directly from code

const getVitalikTokensOnEth = async () => {
 try {
   const response = await fetch('https://1.insight.thirdweb.com/v1/tokens/erc20/vitalik.eth', {
      headers: {
        "x-client-id": clientId,
      },
    });
   const balances = await response.json();
   return balances
 } catch (error) {
   console.error('Error:', error);
 }
};

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

We’ve made significant enhancements to thirdweb Insight, allowing you to efficiently query ERC-20, ERC-721, and ERC-1155 token balances for any address.

We identified latency issues on bigger chains where some requests took over 10 seconds.
Our improved indexing logic has reduced p99 query latency to under 1.5 seconds across all chains.
This is just the first step and we'll keep on improving the performance of Insight

Want to try it out? All endpoints are available on our playground: ERC-20 queries, ERC-721 queries and ERC-1155 queries.

Or integrate them into your app:

const getVitalikNftsOnBase = async () => {
 try {
   const response = await fetch('https://8453.insight.thirdweb.com/v1/tokens/erc721/0xd8da6bf26964af9d7eed9e03e53415d37aa96045', {
      headers: {
        "x-client-id": clientId,
      },
    });
   const balances = await response.json();
   return balances
 } catch (error) {
   console.error('Error:', error);
 }
};

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

Insight open source indexer has received it's first major version upgrade in beta to 1.0.2-beta and brings with it more scalable reorg handling, better reliability and more performance.

• Token Balances API endpoint - The indexer API now has a new `/balances/:owner/:type` endpoint to retrieve token balances by type (ERC20, ERC721, ERC1155) for a specified address. Added features include aggregation support, customizable responses, and options for pagination and filtering.
• Materialized views for token balances - Created materialized views to keep track of token balances as logs are being inserted.
• Chain based table configuration for Clickhouse - when using Clickhouse as a data store, you can now configure table names and default columns.
• Field selection for storage connectors - Specific fields can be fetched via storage connectors to not query everything and improve performance.

• Improved reorg handling with Clickhouse data store - Migrated database tables to use `VersionedCollapsingMergeTree` for better data accuracy and scale when indexing multiple chains.
  NB! This is a breaking change!
• Added serialization for API responses with specific column selection to better control the data returned. Also replaced array-based topics in logs with fixed columns for more reliable data handling.
• Enhanced committing integrity - added safeguards to track the last committed block, preventing data inconsistencies and duplicate insertion.
• Graceful shutdown - Implemented context cancellation for all orchestrator components to support graceful shutdown, improving application reliability during deployment disruptions.
• GetTraces Consistency - Updated trace fetching logic to conform to API standards and enabling consistent pagination and filtering across the codebase

This update introduces substantial improvements in API functionality and performance, database consistency, and overall reliability. These changes facilitate better integration, data retrieval, and system robustness, especially in cloud-deployed environments.

Learn more about Insight and how to use it.
Insight is open source.

We're creating the next evolution of thirdweb Pay with Universal Bridge.

You can now onramp with over 40 fiat currencies to any token using just a credit card. This gives your users zero fees on select currencies, and no KYC required for low amounts.

We've added new chains and new tokens available to bridge and swap. Over 1000 routes were added and more coming.

We're working on improved infrastructure to provide up to 10x faster quotes! These improvements will steadily roll out over the coming weeks.

We've been refining the UI of our prebuilt PayEmbed for all use cases: top up, commerce and transactions. Improvements include: showing fiat values next to token value everywhere, refined token selection flow, better error messaging and more.

• Updated Thirdweb Rust static libraries to v1
  • In-App Wallets now have near 1:1 functionality with Ecosystem Wallets and share the same infrastructure.
  • Existing wallets will be automatically migrated to the new enclave infrastructure upon first login if needed.
• Smart Wallet Factory improvements
  • Factory address is now stored on creation, eliminating the need for repeated declarations in nodes.
• Write Contract node enhancements
  • Now implemented as a K2Node, allowing for raw data input via JSON.

• File length constraint fixes
  • Renamed all async tasks to comply with Epic's new 170-character file length rule, which previously caused issues due to plugin name hashing.
• Unreal Engine Version Specific Compilation Issues
  • Added various conditional imports to additional headers resolving version-specific compilation issues.
• Bug fixes
  • Fixed an issue where abstract class instantiation was attempted from Blueprints; now properly using the HasDedicatedNode meta tag.
  • Resolved an Android packaging error with the Thirdweb plugin in UE 5.4.
  • Fixed a crash on startup when packaging for Mac.
  • Fixed Write Contract ExpandNode Error.
  • Removed Chromium Embedded Framework (CEF) and related project settings.
  • Fixed multiple compilation, build, and packaging issues.

• Improved Examples
  • Updated samples to use the latest fixed nodes.
• DX improvements
  • Various enhancements to Thirdweb editor utilities.
• Other updates
  • Updated copyright to 2025.

Unreal Engine v2.0.0 | Fab Marketplace (May not be up to date at the time of reading this, if that is the case, build from our github source!)

Documentation | Support

You can now use thirdweb dashboard to deploy contracts deterministically (create2) on multiple EVM chains.

To use this feature, deploy any thirdweb prebuilt or a custom contract using thirdweb dashboard. Then navigate to the Cross chain tab on contract page as shown below:

Use the dropdown to select the chain you wish to deploy on. Then click on Deploy button.

Once the contract gets deployed (or if it's already deployed at that address), the status will change to Deployed and you can click the link as shown above to navigate to that chain's contract page.

This feature is available for all thirdweb prebuilt contracts as well as custom contracts that are deployed / published using thirdweb tools. All direct deploy contracts (i.e. not proxy) must be deployed deterministically to enable this feature.

Note: this feature is available only for EVM chains

Go ahead and deploy a contract here.

Previously, the thirdweb dashboard only allowed you to import contracts, without the ability to associate them with specific projects. Contracts were displayed as a single list across teams, projects, and account pages.

Now, you can organize your contracts within projects for better management.

As part of this update, all your deployed contracts have been automatically added to all your projects. You can now review each project and keep only the relevant contracts by removing others from the project

When deploying a new contract, you can now add it to a project immediately.

Existing contracts can be added to projects with the new "Add to Project" button on the contract details page. Here's Doodles NFT contract for example:

Unlike the previous "Import to Dashboard" and "Remove from Dashboard" actions, adding or removing contracts from a project no longer requires signing a message.

The Published Contracts page has been removed from the Teams and Projects pages and is now accessible via your Wallet profile page. A Link to the wallet profile page is also added in the Account Management Dropdown as shown below

Here's the thirdweb.eth profile page for example

• Smart Wallet transaction receipt polling can now time out based on your client "Other" timeout options, similar to normal transactions.
• Our dashboard now supports rotating your secret keys. Rotated secret keys are now supported in this version.
• You can now call InAppWallet or EcosystemWallet's Create function and instantly login with a twAuthTokenOverride which would be an auth token/cookie that you would have retrieved from any other thirdweb app, such as a web app, electron launcher, or any app built using our various SDKs.

var forwardedWallet = await InAppWallet.Create(
    client: myClient, 
    authProvider: AuthProvider.Github, 
    twAuthTokenOverride: "my.auth.token"
);

Previously, it was only possible to go from .NET to other React apps using GenerateExternalLoginLink, this unlocks the other way.

.NET Release | NuGet Release | Unity Release

Documentation | Support

Effective Date: February 11, 2025, at 2:00 PM PST

Since launching in 2021, over 2 million smart contracts have been deployed with our toolkit — powering billions of transactions every year. We’re making some changes to our fee structure to better support the development of our smart contract development toolkit.

Starting on the effective date, a 2.5% platform fee (applied to both native and ERC20 tokens) will be introduced for all prebuilt contracts deployed through the thirdweb dashboard after 2 pm PST on February 11, 2025.

Please note this change does not effect already deployed contracts.

This change applies to any contracts that have a primary sale recipient, including but not limited to:

• Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
• Token Contracts: TokenERC20, TokenERC721, TokenERC1155
• Specialized Contracts: , LoyaltyCard, BurnToClaim, MarketplaceV3

• The 2.5% fee will be automatically deducted from primary sales executed through these contracts. For example, an asset listed at 0.1 ETH will distribute 0.0975 ETH to the seller and 0.0025 ETH to the platform.
• The fee applies only to prebuilt contracts deployed via the thirdweb dashboard. Custom contracts or externally deployed contracts remain unaffected.
• The fee is charged from the primary sale, including a claim or mint action when there is a price on the NFT (non-zero). The fee is paid in the same currency as the claiming or minting price.

This adjustment helps support continued development and maintenance of prebuilt smart contracts, ensuring reliability, security, and innovation for the ecosystem.

For any questions or further details, please reach out to our support team.

• Which prebuilt contracts will have included fees?
  • The following contracts and corresponding modular versions will now include a seller fee:
    • Drop Contracts: DropERC20, DropERC721, DropERC1155, OpenEdition
    • Token Contracts: TokenERC20, TokenERC721, TokenERC1155
    • Specialized Contracts: LoyaltyCard, BurnToClaim, MarketplaceV3
• I deployed a contract prior to the effective date, will these fees apply to me?
  This fee is only applied to any contracts deployed after 2 pm PST on 2/10/2025.
• Can I opt out of the changes?
  • This change only applies to contracts deployed via the dashboard and not any contracts deployed programatically.