Cost to Deploy Smart Contract and How Much Does It Cost to Deploy a Smart Contract in 2026?

If you're thinking about deploying a smart contract in 2026, be ready for a price range that could start at just a few dollars and jump up significantly from there. The cost depends on a bunch of factors like which blockchain you go with, the size of your bytecode, how complex your constructor is, and data availability. This guide has all the latest info and some handy steps to help you estimate and even cut down on those deployment costs.

TL;DR for decision‑makers

When you're setting up a standard ERC‑20/721 contract on the Ethereum mainnet (L1), you can expect to burn through about 1.0-1.5 million gas. If gas prices are hovering around 5-15 gwei and ETH is priced at about $2,500, you're looking at a total cost of approximately $16-$112. Just remember, the final bill really hinges on the size of your code and any storage writes that happen in your constructor. (github.com)
If you’re diving into modern L2s after EIP‑4844, you’ll be happy to hear that fees for more complex transactions are usually only a few cents! And when you start deploying contracts, the costs get even lower because L1 data is now stored in those affordable “blobs.” Make sure to peek at the live fee snapshots before you hit that launch button. (l2fees.info)
So, if you’re diving into non-EVM chains like Solana, NEAR, Sui, Aptos, or Starknet, you’ll notice that deployment costs can really vary. For instance, with Solana, you’ll need a refundable rent-exempt balance that depends on how big your program is. NEAR and Sui have their own storage fees you’ll want to keep in mind. Aptos splits up the costs between execution gas and storage. And don’t forget, Starknet recently tweaked things to make the “declare” and “deploy” fees a bit more friendly. You can check out more details here.

What actually makes deployment expensive (or cheap)

When you hit that “deploy” button, you’re not just doing one thing; you’re actually handling four important tasks (we'll keep it simple with EVM terms, but the same principles work in other settings too):

Transaction and creation overhead: Each transaction will cost you about 21,000 gas. If you’re going the extra mile and creating a contract instead of just making a simple transfer, you’re looking at an additional 32,000 gas on top of that. For more info, take a look here.
Calldata/Initcode: When you send bytes to create a contract--this includes the constructor and the code--you're looking at a cost of 4 gas for every zero byte and 16 gas for each non-zero byte. Since the Shanghai upgrade, they’ve changed how initcode is metered as well. Now it’s 2 gas for each 32-byte word, with a maximum limit of 49,152 bytes. If you want to dive deeper, check out the details here.
Code deposit: When you're deploying runtime bytecode, it costs 200 gas for each byte. If your contracts are loaded with code, those fees can quickly pile up. Want to learn more? Check it out here.
Constructor execution: Whenever you're working with opcodes--especially with SSTORE writes--be mindful of the costs involved. If you set a zero slot to something non-zero, it’ll set you back 20,000 gas. On the flip side, updating an existing value only costs 5,000 gas. Just a little reminder: refunds have their limits due to EIP‑3529. Plus, keep in mind the warm/cold access rules--accessing a cold SLOAD will hit you with 2100 gas, but a warm one is way cheaper at just 100 gas. If you want to dive deeper, check it out here.

Here are a couple more dynamics to keep an eye on for 2026:

L2 “blob” fees after EIP‑4844: With the introduction of the new blob market through EIP‑4844, rollups now get to publish their data in a dedicated space alongside its own base fee. This tweak has slashed L2 costs by a huge margin--like over 90% in many instances! It’s a game changer for contract deployment on L2s, especially since that can really chew up a lot of bytes. (blocknative.com)
Contract size limits today and what may change: Currently, the mainnet has a hard limit of 24KB due to EIP‑170. There’s an interesting draft EIP‑7907 floating around that proposes raising that limit to somewhere between 48-64KB+, while also keeping an eye on the size. Just a quick note--this is still in draft form as of January 7, 2026, so it’s a good idea to stick with the 24KB cap for the time being. (eips.ethereum.org)

What it costs on major networks in 2026

Be sure to take a quick look at the current gas and token prices right before you hit that deploy button. Still, the benchmarks below should give you a solid idea of what to expect for your budget.

Ethereum L1 (Mainnet)

If you're rolling out an ERC-20 token using OpenZeppelin, you can typically expect gas fees to sit between 1.2 and 1.4 million. Based on community insights, the average tends to be around 1.31 million gas. Just so you know, the cost of the code deposit depends on the length of the runtime bytecode, which is about 200 gas for each byte. (github.com)
Alright, let’s take a closer look at how much 1.3 million gas costs depending on different gwei levels:
- At 5 gwei: you’re shelling out around 0.0065 ETH (that’s about $16 if ETH is sitting at $2,500)
- At 15 gwei: it's going to cost you roughly 0.0195 ETH (which is around $49)
- At 40 gwei (when things get really busy): you can expect to spend about 0.052 ETH (that's about $130)
After the Dencun upgrade in March 2024, gas fees sometimes dropped quite a bit throughout 2025, but there were still some fluctuations. So, it’s smart not to just bank on “cheap ETH” when you’re sketching out your business case--be sure to explore a few different scenarios. (cointelegraph.com)

Practical tip: If your constructor is initializing a bunch of state variables, keep in mind you'll rack up a gas fee of 20,000 for each slot that shifts from zero to non-zero. To help keep your deployment costs down, consider switching constants to immutables. You can dig into the details here: (eips.ethereum.org)

Ethereum L2s (Arbitrum, Optimism/Base, zkSync, Polygon zkEVM, Starknet)

If you're wondering what the current sample fees are for standard actions, take a look at L2fees.info. Most of the transfers are just under a dime, and you’ll find swaps often coming in below 50 cents. Deployments can be a bit more expensive, but they definitely benefit from that post-4844 blob pricing. (l2fees.info)
Base (OP Stack) breaks down two key components for you: an L2 execution fee and an L1 data fee. They also have a minimum base fee set at 0.0005 gwei, which helps keep things predictable and minimizes spammy activity. With this minimum in place, most of your everyday transactions will only cost you a couple of fractions of a cent. (docs.base.org)
Starknet has a pretty cool system for breaking things down into DECLARE (which is for registering a class) and DEPLOY (which is what actually creates it). The fees involved depend on the L1 data you’re posting and the L2 gas you’re using. With the update to v0.13.1.x, folks saw a significant drop in declaration costs in 2025, which is fantastic news for anyone working with Cairo 1 codebases. And hey, make sure to use SDK fee estimators in your CI to snag the most accurate preflight figures. (docs.starknet.io)
Quick heads-up: zkSync just let us know that Etherscan indexing support will be coming to an end on January 7, 2026. Make sure to factor in any changes related to explorers and APIs when you’re planning your operations budget. (kucoin.com)

Polygon PoS

On the mainnet, every transaction--deployments included--runs on EVM gas, and there’s a mandatory minimum priority fee of 30 gwei. If you’ve got your tools set to low priority fees, you might run into some problems. For more info, take a look here: (docs.polygon.technology)

BNB Chain (BSC)

Back in October 2025, validators decided to lower the minimum gas price to around 0.05 gwei, down from 0.1. This tweak meant that a bunch of transaction fees became just tiny fractions of a cent, leading to some scaling back on deployments. So, it's a good idea to keep an eye on the latest validator-recommended floor for the most up-to-date info. Check it out here: (kucoin.com)

Avalanche C‑Chain

The Avalanche9000 upgrade that launched on December 16, 2024, made a huge change by cutting the minimum base fee from 25 nAVAX down to a mere 1 nAVAX. Thanks to this, average usage fees took a nosedive of around 75%! When you're deploying contracts on the C‑Chain, it sticks to EVM rules, and everything's priced in AVAX according to these new base fee levels. If you’re curious to dive deeper into this, check it out here.

Solana

When you're getting ready to deploy a program, you'll need to toss some funds into the program account until it reaches the rent-exempt minimum based on its size. But don't stress--it's just a refundable deposit! The base transaction fee is 5,000 lamports for each signature, which is about 0.000005 SOL. If you want to push things along a bit faster, there are optional priority fees you can add based on compute units. The great part? Unlike EVM, you won’t have to worry about a code-deposit fee per byte! To check out the minimum amount you'll need, simply run solana rent . For the nitty-gritty details, head over to (solana.com).
As we look ahead to 2025-2026, there's a bit of a shift coming with the compute unit policy. The standard transaction compute unit (CU) limit will be around 200k, but if you want to aim higher, you can ramp it up to 1.4M by using a budget instruction. The base fee stays at 5,000 lamports per signature. And here’s the kicker: the CU price is actually zero unless you decide to toss in a tip for some priority. Want to dive deeper? Check out more on this at (quicknode.com).

NEAR

When you're looking at deployment costs, the big factor to think about is storage staking. It costs about 1e19 yoctoNEAR for every byte of storage, which works out to around 100 KB for every 1 NEAR you stake. Essentially, you end up "locking" tokens based on how much storage your contract consumes. The cool part? You can unlock those tokens if you decide to free up some storage! And don't worry about transaction fees--they're super low, usually just a few cents! (docs.near.org)

Sui

Whenever you make a transaction, you’ll encounter an execution fee along with a storage fee that's based on something called “storage units.” Currently, the storage fee is at 76 MIST per unit. But no worries! You can always check the most up-to-date rate right on-chain. Just run a quick GraphQL query for storage_gas_price before you hit deploy. And remember, these storage fees are included in the total gas charge. (docs.sui.io)

Aptos

Aptos separates execution/IO gas from storage fees, which is pretty cool. You’ll notice that storage is billed in fixed APT octas, and if you decide to delete some slots, you can actually get a refund! When you're publishing packages, the costs vary based on the size of your code and the resources you set up. And don’t worry, you can run a simulation to get a solid estimate of what you'll spend. Take a look here: (aptos.dev)

Concrete examples you can copy into your budget

Take a look at these “order-of-magnitude true” examples that you can easily customize for your spreadsheets. Just replace the current ETH/SOL/AVAX prices and update the live gas/fee inputs whenever you need to.

Ethereum L1 ERC‑20 (OpenZeppelin‑based), 1.3M gas:
- When the network isn’t too crowded (5 gwei, $2,500/ETH), you’re looking at around 0.0065 ETH, which is about $16.
- But during those busy times (40 gwei), that can skyrocket to approximately 0.052 ETH, roughly $130.
  Just a quick reminder: keep your runtime bytecode under 24KB (EIP‑170). If you go over, you might need to consider breaking up your logic a bit. (github.com)
Whether you’re using Arbitrum or Base, they both rely on the same ERC‑20:
- A big chunk of the fees comes from Layer 1 data through blobs. Generally, for more complicated transactions, you’re looking at costs that are usually under $0.50. Deployments can be a bit pricier compared to straightforward transfers or swaps, but they're often still under a dollar or in the low single digits. To see for yourself, you can check it out with eth_estimateGas and dive into the fee breakdown API for the L2. (l2fees.info)
Solana program, 250 KB:
- To get started, you'll need to cover the rent-exempt minimum. You can find this by running solana rent 256000, and you'll also want to account for a few signatures. The cool part? You'll get that deposit back if you decide to close or undeploy your program. When it comes to transaction fees, expect to shell out around ~0.000005 SOL for each signature--unless you opt for some priority fees. For more details, check it out on (solana.com).
Avalanche C‑Chain ERC‑20:
- It runs on the same gas units as Ethereum, but you’ll typically find the costs hovering around just 1 to a few nAVAX post-upgrade. To get a ballpark figure for your transaction, simply multiply your gas estimate by the current nAVAX gas price. For a rough estimate in dollars, check it out here: (build.avax.network)

9 emerging best practices (2026) to shrink your deployment bill

Treat bytecode like cash

Every byte you deploy racks up a 200 gas charge on EVM chains, so it's a good idea to keep an eye on your runtime bytecode size. Consider swapping out those revert strings for custom errors, use immutables instead of constructor-set storage, and don’t forget to clean up those unused imports. OpenZeppelin 5.0 has shown some significant savings, with double-digit drops in deployment costs thanks to these simple tweaks. (eips.ethereum.org)

2) Choose the Right Optimizer Strategy

Opting for a lower number of optimizer "runs" can help keep your deployment costs down, but just a heads up--it might bump up your runtime expenses a bit. On the other hand, if you go for higher runs, you could see the opposite effect. If you’re dealing with contracts that get called frequently, it’s usually worth it to spend a bit more during deployment to save money on each call. But for those one-off controllers, sticking with lower runs is often the way to go. You can find more details in the Solidity docs. (docs.soliditylang.org)

3) Move Constructors Away from SSTORE

When you write to storage and go from zero to non-zero, you’re looking at a hefty 20,000 gas fee. And if it’s a cold access on the first touch, that’s extra pain in your wallet. To ease the burden, think about switching constants to immutable. Also, it’s a good idea to initialize mappings only when you actually need them and set defaults right in your code rather than storing them. You can dive into the nitty-gritty details here: (eips.ethereum.org)

4) Opt for Minimal Proxies (EIP-1167) or UUPS When Possible

Clones are super lightweight, needing just about 45 bytes of runtime code, and they link to a single implementation. This setup can save you roughly 10-20 times the cost you'd incur if you had to redeploy the whole logic each time. Plus, when it comes to upgrades, UUPS proxies keep things nice and tidy by minimizing the proxy bytecode, which also cuts down on your deployment costs compared to the Transparent proxies. Check it out here: (eips.ethereum.org)

5) Pre-flight with Real Estimators (and Don’t Forget the Buffer)

Before you get started, try using eth_estimateGas with mainnet or L2 RPCs. And hey, it's smart to add a 10% buffer just to be safe! This handy tip comes straight from the OpenZeppelin relayer docs. If you're working with Starknet, don't forget to use estimateDeclareFee or estimateDeployFee. And if you’re on Solana, it's a good idea to run solana rent beforehand. You can find more info here.

Stay DA-aware on L2s

Since EIP-4844 dropped, blob fees are now a whole different ball game, independent from calldata and the base fee. It’s a good idea to schedule your major deployments during those quiet L1 hours and keep tabs on the blob base fee. If you're looking to get the lowdown on this three-part fee structure, Blocknative’s “blobsplaining” is super helpful. Give it a look here: (blocknative.com)

7) Watch Out for Network-Specific Fees and Tips

When you're diving into different networks, don't forget about those pesky fees! For example, Polygon's PoS requires at least a 30 gwei tip, while Base has a minimum base fee of 0.0005 gwei. On the BNB Chain, you’ll find a validator-driven floor of 0.05 gwei. If you miss these details, your "$0.00x" estimate could easily be off by 10 to 20 times. Check out more info here!

8) Plan for Size Caps and Proposals

Make sure your designs stay under 24KB, sticking to EIP‑170. While EIP‑7907 is looking to accommodate bigger contracts, it’s still just a draft as of January 7, 2026--so it’s probably best not to count on it for a Q1 launch. If you find yourself needing some “unlimited” logic, check out ERC‑2535 diamonds and their modular facets. (eips.ethereum.org)

Keep storage off-chain unless it’s absolutely necessary

Storing data on-chain can really add up in costs, so it’s a good idea to consider using IPFS, Filecoin, or Arweave for your media and metadata. Pinata does a great job of breaking down how mainnet storage costs can be jaw-dropping compared to decentralized alternatives. Take a look here: (pinata.cloud)

2026 deployment checklists, with precise steps

A) Ethereum (L1 or L2 EVM) pre‑deploy

Gas/Fee Model
- Check out the current base fee and priority ranges (and blob base fee if you’re operating on L2) for a quick overview. Then, put together at least three budgets: P50, P90, and those nerve-wracking worst-case spikes from 2019. And hey, don’t forget to swing by L2fees.info to get a real sense of today’s fees.
Code Size and Limits
- Keep an eye on your runtime bytecode - it should stay under 24KB. If you're nearing that limit, you might want to look into using libraries, proxies, or diamond patterns. And hey, if your features are getting a bit too bulky, consider splitting them into smaller facets. For more details, check out EIPs.ethereum.org.
Gas Audits
- It's time to upgrade to custom errors! Make sure to label your constants as immutable and tidy up any unused code. Then, rerun the compiler with fewer “runs” for components that are a bit heavy on deployment, and crank up the “runs” for the more frequently used paths. You can dive deeper into the details at docs.soliditylang.org.
Estimation
- Go ahead and run eth_estimateGas on your chosen RPC, and make sure to toss in a 10% buffer while you're at it. Oh, and don’t skip the code deposit math: 200 * runtime_bytes. If you're working with factories, it’s a good idea to figure out the costs for child deployments ahead of time (think clones versus full deployments). You can find more details here: EIPs.ethereum.org.
Tooling & Explorers
- If you’re using Etherscan APIs, make sure to watch out for the pricing and rate limits coming in 2025-2026. The free tier allows you to make 3 requests per second and up to 100,000 requests a day, while paid plans kick off at $49/month. The silver lining? The V2 APIs are now consistent across all chains. You can take a look at it on etherscan.io.

B) Solana program deploy

Build size and rent
- Start by running wc -c target/deploy/program.so to find out the byte size. After that, use solana rent to determine the rent-exempt minimum. Just a heads up--it's smart to set aside a bit more for transaction fees. You can check out more details here: (solana.com)
Fee Policy
- Generally, you can count on paying about 5,000 lamports for each signature as a base fee. If you're in a race against the clock, go ahead and tack on some priority fees. And if you really need a boost, you can bump up the Compute Unit (CU) limit to 1.4M by using ComputeBudget instructions. For more info, check it out here: (solana.com)

C) NEAR/Sui/Aptos/Starknet specifics

NEAR: If you're trying to calculate storage costs, it's pretty straightforward--just multiply the code and state bytes by 1e19 yoctoNEAR/byte. In layman's terms, that's around 100KB per NEAR. Keep in mind that storage is something you stake, not just an expense. Check out more details here.
Sui: You can easily get the storage_gas_price through GraphQL. The best part? The storage fee is rolled into your overall gas charge. Check it out here: (docs.sui.io)
Aptos: When you're trying to simulate a package publish, you'll notice that the fee statement breaks down the execution/IO gas and the storage fee into octas. The great part? If you decide to delete it later, you can get that money back! Check it out here: (aptos.dev)
Starknet: First, run estimateDeclareFee, and then take a look at estimateDeployFee. By the way, version 0.13.1.1 made a huge difference in declare fees back in 2025, cutting them down significantly. (cointime.ai)

Hidden and adjacent costs most teams miss

Node/API infrastructure: If you're self-hosting, it's pretty common for teams to go with managed RPCs to keep everything running without a hitch. Here’s a quick price breakdown for you: Infura has a Developer plan that costs $50 a month and a Team plan priced at $225 a month (they use a credits model). QuickNode offers plans that start off free and scale all the way up to enterprise options with generous credit limits. And don’t forget to factor in the Etherscan API if you're looking to hit those higher rates! (infura.io)
Security reviews: As we look toward 2026, it’s clear that the price tag for reliable audits can really fluctuate. For straightforward tokens, you’re generally talking about around $8k, but if you’re dealing with more complex protocols, that can jump to anywhere between $100k and $300k or even more. Public benchmarks indicate that weekly rates tend to sit around $20k. Many teams prefer to mix things up by pairing a traditional audit with a Code4rena-style contest and a bug bounty for that added layer of reassurance. (sherlock.xyz)
Data storage: Off-chain decentralized storage can save you a ton of cash compared to on-chain options. Just take a look at the pricing for Storj/Filecoin, which charges you in dollars per GB each month. When you compare that to the rising costs of mainnet calldata and storage -- thanks to ETH and gas fees -- it’s clear where the better deal is. (blockeden.xyz)

Two worked mini‑case studies

1) Multi‑tenant vaults on Ethereum (hundreds of instances)

Baseline naive plan: If we were to deploy 200 full copies, we'd be looking at a cost of around 1.5M gas each, which adds up to a staggering 300M gas total.
Clone/UUPS plan: But hold on! Instead, we could go with just one implementation (still around 1.5M gas) and create 199 clones, each using roughly 20-50k gas. That brings our total down to about 2.5-3.5M gas--now that's some serious savings! This is exactly why projects like Uniswap pairs and wallet factories love using ERC‑1167. Want to learn more? Check it out here: (eips.ethereum.org)

2) Consumer App on Base (OP Stack) with Weekly Feature Updates

When you're diving into the consumer app space on Base, one thing you'll definitely want to keep an eye on is those L1 data fees - they can really add up. A clever move is to plan your updates for the weekends when both the L1 basefee and blob basefee tend to drop. Thanks to Base’s minimum basefee, you can keep things running smoothly for users. This way, your larger deployments can roll out right on time, and the costs usually stay pretty manageable, often just in the low dollar range. Check out more details in the Base documentation.

2026 watch‑list that can move your costs

EIP‑7907 (draft): This proposal focuses on metered code size and possible increases to the limits. If it gets approved, it could raise the current 24KB cap, but just a heads up--you'll need to fork out a bit more for any larger code. So, it might be wise to hold off on budgeting for this in Q1’26. You can dive into the details here.
Calldata Repricing Proposals (EIP‑7623/7976 drafts): These proposals aim to increase the costs for data-heavy transactions, encouraging developers to shift towards blobs instead. This change could also impact L2 operator costs and any tools that rely heavily on L1 calldata. You can check out more details here.
Explorer/API changes: Just a heads up, Etherscan is moving over to API v2, and zkSync will stop indexing on Etherscan starting January 7, 2026. So, it’s a good time to double-check that your DevOps integrations are current! You can find more info about it here.

How 7Block Labs helps teams cut deployment spend by 30-90%

Design with size in mind: We break things down into libraries, immutables, and facets to keep our runtime bytecode nice and light.
Choosing the right proxy: For spinning up multiple instances quickly, we go with ERC‑1167 clones, use UUPS for upgradeable cores, and call in diamonds when we need some extra modularity. (eips.ethereum.org)
Smart fee-aware release trains: Our CI connects to live fee oracles (like L1 basefee + blob basefee/L2 pricing), picks the best windows, and runs gas simulations for each chain before we make any switches. (blocknative.com)

If you're on the hunt for a deployment budget that fits your unique stack (whether it's EVM, Solana, NEAR, Sui, Aptos, or Starknet), you're in the right place! We can put together a one-page forecast with P50, P90, and worst-case scenarios in just 48 hours.

Quick reference: formulas you’ll actually use this week

EVM Deploy Rough Cost (ETH):
If you want to estimate your deployment cost, here’s a simple formula to follow:
gas_used × gas_price (in ETH/gas)
Let’s break down what gas_used means: It’s typically around 21,000 + 32,000 + (200 × runtime_bytes) + constructor_gas + calldata_gas. Don’t forget that initcode metering adds about 2 gas for every 32 bytes of initcode, and keep in mind the size limit is 49,152 bytes. If you’re looking for more info, check this out: (eips.ethereum.org)
Solana Program Rent:
Curious about how to keep your program rent-free? Just run this command:
solana rent
This will let you know how many lamports you need to hang onto for that rent-exempt status (and good news -- it’s refundable!). Also, keep in mind that the base fee per signature is 5,000 lamports, plus there's an optional CU priority fee if that’s your thing. You can check out more details here: (solana.com)
NEAR Storage Staking:
If you're wondering how much NEAR you need to stake for storage, it's pretty straightforward! Just use this quick formula:
Bytes ÷ 100,000
This will tell you how much NEAR you'll need for storage, which comes out to about 100KB per NEAR. For more info, check out this link: (docs.near.org)

Bottom line

These days, the cheapest dollar you can spend is the byte that you skip deploying. So, consider going on a bytecode diet: use constructors that won't write to storage and choose the right proxy carefully.
Since the post‑4844 update, deploying on Layer 2s has become pretty affordable, but don’t overlook those fee-aware release windows.
If you’re working with non‑EVM chains like Solana, NEAR, or Sui, make sure to keep an eye on your storage footprint. And don’t forget to use chain-specific fee estimators (like those for Aptos and Starknet) when you're in continuous integration.

Want a fixed-fee “Deployability Review” for your codebase? We’ve got your back! This review includes a gas report that shows you the before-and-after results, plus a cost forecast for each chain. Just jump on a quick call with 7Block Labs, and we’ll sort it all out together.

References and data sources: If you’re looking for all the fee constants and limits, be sure to check out the EIPs and the core docs. For real-time Layer 2 costs, don’t miss L2fees.info. You can get detailed info on networks like Base, Avalanche, BNB, Polygon, Solana, NEAR, Aptos, and Starknet in their official documentation. And for some handy optimization tips, take a look at OpenZeppelin and Solidity documentation. (eips.ethereum.org)