How Much to Charge for an n8n Automation

By Omar Yousaf, Founder of Digital Solo Hub

Last updated: October 20, 2026

Quote = build hours × floor rate × 1.25

That one line is the whole method. The rest of this page shows you how to fill it in honestly.

Most beginners price an n8n workflow by looking at the canvas.

Twelve nodes? Must be a big job. Four nodes? Must be cheap.

It isn’t that simple. A four-node workflow that talks to a badly documented API, needs a login the client can’t find, and has to survive bad data can take a full day. A twenty-node workflow made of simple field mappings can take an afternoon. The client sees nodes. You pay in hours.

What this guide covers (and what it doesn’t): this page answers one question: what should you charge for building an n8n workflow? It deliberately does not cover:

• Which automation tool to learn or sell, and how each one bills. That’s Zapier vs Make vs n8n for freelancers.
• How to find automation clients. See First Clients for an AI Automation Agency, and if you want one simple first offer to lead with, the missed call text back build.
• Writing the scope document itself. Use the automation scope of work template.

Every dollar figure on this page is an example built from the formula above, at an illustrative $25 an hour floor. None of it is a market rate, and none of it is a promise of what you’ll earn.

Key Takeaways

• Price hours, not nodes. Node count tells you almost nothing about how long a build takes.
• Quote = build hours × floor rate × 1.25. The 25% pays for messages, client testing, and one round of fixes.
• Your floor comes from your own costs, not from a number you saw on another site. The rate calculator gives you the minimum hourly rate to plug in.
• Quote one flat price for a defined build. Use hourly only when the scope is genuinely unknown, and a retainer only for ongoing maintenance.
• Hosting is a scoping question. Decide who runs n8n and who pays for it before you quote, because self-hosting adds setup and upkeep hours.
• Write down what triggers a re-quote, so “one more small thing” becomes a new price instead of free work.

Table of Contents

• How Much to Charge for n8n Automation: The Formula
• Three Worked Examples at an Illustrative $25 Floor
• Hard Truth: Node Count Is the Wrong Thing to Price
• Step 1: Get Your Floor Rate (Your Minimum, Not a Market Rate)
• Step 2: Estimate Build Hours (What to Count)
• Step 3: Multiply, Add 25%, Round Up, Quote One Price
• Which Pricing Model to Use: Flat Price vs Hourly vs Retainer
• Self-Hosted vs n8n Cloud: A Scoping Question, Not a Price Tag
• What Makes an n8n Build Take Longer
• Scope Boundaries: What’s Included and What Triggers a Re-Quote
• n8n Pricing Checklist (Copy This)
• Copy-Paste n8n Quote Template
• Scripts for the Pricing Questions Clients Ask
• Pricing Mistakes I See (and the Fix for Each)
• The 45-Minute n8n Pricing Setup
• Frequently Asked Questions
• Final Thoughts

How Much to Charge for n8n Automation: The Formula

To work out how much to charge for an n8n automation, estimate the hours the whole build takes (mapping, credentials, nodes, error handling, testing and handoff), multiply by your floor rate, then multiply by 1.25 to cover messages, client testing and one round of fixes. Round up and quote that as one flat price.

Three inputs, one multiplier:

• Build hours: your honest estimate of every task on the job, not just the time on the canvas. Step 2 below shows what to count.
• Floor rate: the lowest hourly figure that still covers your bills, tools, tax and unbilled time. It’s the line you don’t quote below.
• 1.25: the buffer for the work around the build. Replies to the client, re-testing after their feedback, and one included round of fixes.

Floor rate → estimated build hours → × 1.25 → round up → one flat price

If you’ve already read the rate calculator page, this is the same idea applied to one kind of job. The calculator tells you what an hour of your time has to cost. This page tells you how many hours an n8n build really holds.

Three Worked Examples at an Illustrative $25 Floor

These three examples use the formula above with a $25 an hour floor chosen only to make the math easy to follow. The hours are assumptions for a beginner who knows n8n basics. They’re not measurements from real clients.

Example build (illustrative)	Assumed build hours	Formula	Example quote
Simple workflow: website form → new row in Google Sheets → Slack alert to the owner, plus an error alert	About 4	4 × $25 × 1.25	About $125 (example)
A workflow with a few steps and one round of fixes: new lead → duplicate check in the CRM → branch by service type → create the record → send a templated reply → notify the owner	About 12	12 × $25 × 1.25	About $375 (example)
A workflow with an AI step and a human check before anything is sent: customer email arrives → AI drafts a reply → owner approves or rejects it in Slack → approved reply goes out → everything is logged	About 24	24 × $25 × 1.25	About $750 (example)

These are not what you will earn. They’re what the formula produces when you plug in one made-up floor and three assumed hour counts. Replace $25 with the minimum hourly rate you get from the rate calculator, and replace the hours with your own estimate for the client in front of you.

Notice what changed between the rows. It wasn’t the node count. It was the number of decisions, the number of systems that could fail, and the fact that the third workflow can’t be allowed to send anything a person hasn’t approved.

Hard Truth: Node Count Is the Wrong Thing to Price

Pricing per node feels fair because the client can see the nodes.

It’s still the wrong base.

The nodes are the visible result. The hours sit in places the canvas doesn’t show:

• Access. Waiting for the client to create an API key, approve an OAuth screen, or find out who owns the CRM login.
• Data. Field names that don’t match, phone numbers in five formats, dates that arrive as text.
• Failure paths. What happens when the CRM is down, the form sends a blank field, or the AI step returns nonsense.
• People. Approvers, reviewers, and the client who wants to “just see one more test run”.

Contrarian Insight: node count isn’t useless. It’s a decent warning sign. A canvas that keeps growing usually means the scope is growing too. Use it to ask “has this changed?”, not to set the price.

Step 1: Get Your Floor Rate (Your Minimum, Not a Market Rate)

Your floor is the lowest hourly figure that still pays your bills after everything comes out. It isn’t what you hope to charge, and it isn’t a rate copied from someone else’s blog post.

To get it, you need your own numbers:

• The monthly income you need to keep. What covers your life, not what you’d like.
• Monthly business costs. Software, AI tools, hosting for your own test instance, hardware savings.
• Tax and time off. Self-employed income isn’t take-home pay.
• Billable hours. Sales calls, proposals, learning and admin aren’t billable. You’ll bill fewer hours than you work.

The free AI freelance rate calculator does this math and shows you a minimum hourly rate. That minimum is your floor. Plug it into the formula wherever this page says $25.

Pro tip: if you sell through a marketplace that takes a fee, the fee comes out of your price. Gross your floor up for it first, or you’re quietly working below your minimum. The calculator has a platform-fee field for exactly this.

Step 2: Estimate Build Hours (What to Count)

This is where most n8n quotes go wrong. People count the hours on the canvas and forget everything around it.

Count every one of these, even if some come out at zero for a given job:

What to count	What it covers	Easy to forget because
Discovery and mapping	Turning the client’s description into trigger → steps → output → error path, and confirming every field	It feels like “just talking”, but it’s where the build gets decided
Credentials and access	API keys, OAuth connections, test accounts, permission problems	You can’t control how fast the client responds
Hosting or instance setup	Setting up a self-hosted instance, or getting access to the client’s n8n Cloud workspace	It’s zero on some jobs and a real chunk on others
Building the nodes	The happy path: trigger, logic, actions	This is the only part most people count
Data mapping and clean-up	Expressions, formatting, splitting and merging data	Messy data shows up only when real records flow through
Error handling	An error workflow with an alert, plus checks for blank or bad input	It doesn’t show up in a demo, so beginners skip it
Your test pass	Running real and edge-case data through every branch before the client sees it	A single successful run feels like “done”
Handoff docs	A short runbook, the exported workflow, a walkthrough	It happens after the build feels finished
The fixes round	One round of changes after the client tests	Don’t count it twice: it lives inside the × 1.25

Here’s how the three examples above break down. These hours are assumptions for illustration, not a standard:

Line item (assumed hours)	Simple workflow	A few steps + fixes	AI step + human check
Discovery and mapping	0.5	1.5	3
Credentials and access	0.5	1	1.5
Hosting or instance setup	0 (client already on n8n)	0 (client already on n8n)	0 (client already on n8n)
Building the nodes	1.5	4	7
AI prompt and output checks	n/a	n/a	4
Human approval step	n/a	n/a	2
Data mapping and clean-up	included in build	1.5	included in build
Error handling	0.5	1	1.5
Your test pass	0.5	2	3
Handoff docs	0.5	1	2
Total build hours	4	12	24

Copy this worksheet into your notes and fill it in after every discovery call:

N8N BUILD ESTIMATE: [client] / [workflow name]
Trigger: [form / webhook / schedule / email / app event]
Apps and credentials: [list]
Who hosts n8n: [client's n8n Cloud / client's server / to be decided]

Line item                          Hours
Discovery and mapping              [ ]
Credentials and access             [ ]
Hosting or instance setup          [ ]
Building the nodes                 [ ]
AI prompt and output checks        [ ]
Human approval step                [ ]
Data mapping and clean-up          [ ]
Error handling                     [ ]
Your test pass                     [ ]
Handoff docs                       [ ]
TOTAL BUILD HOURS                  [ ]

Quote = [total] x [floor rate] x 1.25 = [price], rounded up
Includes: one round of fixes. Second round = re-quote.

My strategy: if you haven’t built this kind of workflow before, build a rough version in your own test instance before you quote. An hour of practice beats a guess, and you’ll find the awkward API before the client is paying for it.

Step 3: Multiply, Add 25%, Round Up, Quote One Price

Take your total build hours, multiply by your floor, multiply by 1.25, and round up to a clean number.

Then quote one flat price for the build as written. Not “about 12 hours at my rate”. Not a range. One number, with a one-line scope and what’s included.

Why flat? Because the client is buying a working workflow, not your time. And because you’ll get faster. The third lead-routing workflow you build will take less time than the first. With a flat price, that speed is your margin. With hourly billing, it’s a discount you hand back.

When to use a bigger buffer: if there are several approvers, the client already sounds chatty on the discovery call, or you’re working with an API you’ve never touched, use 1.4 instead of 1.25 and say why in your notes. Don’t change the formula to win the job. Change the scope.

Which Pricing Model to Use: Flat Price vs Hourly vs Retainer

You’ve got the number. Now decide how to present it. The hours underneath don’t change.

Your situation	Quote as	Why it works	Guardrail to write down
A defined build: clear trigger, clear apps, clear output	Flat price for the build	Easy for the client to approve; your speed becomes margin	One round of fixes included; changes after that are re-quoted
Messy or unknown scope: “fix our broken workflows”, no access yet	Hourly with an estimate range and a check-in point	Protects you from what you can’t see yet	“Estimate [x] to [y] hours. I’ll check in before hour [y].”
Ongoing care after launch: monitoring, small changes, API updates	Monthly retainer	Predictable for both sides	Hours per month, response time, what counts as a new build
A big project with several workflows	Flat price per phase	Each phase is small enough to estimate honestly	Phase 2 is quoted after phase 1 is accepted

How to price an n8n maintenance retainer

Use the same formula, with monthly hours instead of build hours: expected maintenance hours per month × floor rate × 1.25.

What usually goes into those hours:

• Checking the error alerts and the executions list.
• Fixing breaks when a connected app changes a field or an API.
• Small wording or routing changes the client asks for.
• Updating the instance, if you’re the one responsible for a self-hosted setup.

Write the monthly hours and response time into the retainer. Anything that adds a new trigger, a new app or a new branch is a new build with its own quote, not retainer time. The automation handoff checklist covers when a retainer makes sense versus a clean handoff. If the monthly work includes call minutes, as with a voice AI that answers the phone, see how much to charge for an AI receptionist.

Self-Hosted vs n8n Cloud: A Scoping Question, Not a Price Tag

Before you quote, settle where the workflow will run and who’s responsible for it. This changes your hours, so it belongs in the estimate.

n8n’s docs describe two main options. n8n Cloud is fully managed: n8n handles hosting, updates and scaling. Self-hosted means you, or the client, provide and manage the infrastructure, and the docs list maintenance as “your responsibility”. Self-hosted installs run on Docker, Docker Compose or a cloud provider, and without a license key they run as the free Community edition.

For your quote, that turns into four questions:

• Who pays for hosting? My default: the client pays for their own n8n Cloud plan or their own server, in their own name. You don’t want to be their hosting company by accident.
• Who sets it up? If you’re installing a self-hosted instance, those hours go in the “hosting or instance setup” line. If the client already has n8n Cloud, that line may be close to zero.
• Who keeps it running? Self-hosted means someone has to monitor and update it. If that’s you, it’s retainer work, not a free extra.
• How much will it run? Per n8n’s docs, paid plans have an execution limit, and only production executions count toward it. Ask about expected volume so the client isn’t surprised by their plan. How each tool counts usage is covered in the Zapier vs Make vs n8n comparison, including what n8n’s license allows when you charge for the work.

Hard Truth: “I’ll just host it on my server” sounds helpful on the call. It turns into a long-term responsibility you never priced. Put hosting in the client’s name and in the scope.

What Makes an n8n Build Take Longer

Use this table on the discovery call. Every “yes” adds hours to your estimate, which is why you price after the call, not before it.

Driver	Why it adds hours	Question to ask
More apps and credentials	Each connection needs access, testing and its own failure path	“Which systems does this touch, and who owns each login?”
Branching logic	Every branch needs its own test data	“Does every request get handled the same way?”
Messy or inconsistent data	Clean-up and formatting steps	“Can you send me ten real examples?”
Large volumes or batches	Pagination, batching and timing	“How many of these happen on a busy day?”
An AI step	Prompt work, output checks, handling bad answers	“What should happen if the AI gets it wrong?”
A human approval step	The workflow has to pause, wait and resume cleanly	“Who approves, and how fast do they usually reply?”
Self-hosting	Setup now, upkeep later	“Where should this run, and who looks after it?”

About AI steps specifically: n8n supports human review for AI tool calls, where the workflow pauses until a person approves or denies the action. n8n suggests it for tools that do irreversible things, such as sending messages or deleting data. If the build sends anything to a customer, price that check in. It’s worth every hour.

Scope Boundaries: What’s Included and What Triggers a Re-Quote

A flat price only works if both sides know where it ends. Put this in writing with your automation scope of work template.

Usually included in the flat price

• The workflow as mapped: one trigger, the listed apps, the listed output.
• An error workflow that alerts a named person. n8n lets you set one in workflow settings; it must start with the Error Trigger node and can serve several workflows.
• Your test pass with real and edge-case data.
• One round of fixes after the client tests.
• Handoff: a short runbook and the exported workflow.

Things that trigger a re-quote

• A new app, trigger or branch that wasn’t in the map.
• Adding an AI step, or removing the human check from one.
• A second round of fixes, or changes to how the client’s process works.
• Volume much higher than the client described.
• Moving the workflow to a different host or account after delivery.
• Credentials or access that arrive so late the job sits idle. Write a “paused after [x] days” line so the clock doesn’t run on your side.

The re-quote rule: new work gets the same formula. Estimate the extra hours, multiply by your floor and 1.25, and send a one-line change note before you build it. The freelance revision policy has wording for the “one round included, then it’s paid” part.

One handoff detail to know: exported n8n workflows are JSON files that include credential names and IDs. n8n advises removing or anonymizing that information before sharing a workflow file. Build in the client’s account so you hand over ownership, not a file with your connections in it.

n8n Pricing Checklist (Copy This)

Check	Done when
Floor rate	You have a minimum hourly rate from your own numbers, grossed up for any platform fee
Discovery call	Trigger, apps, owners, volume and the “what if it fails” answer are written down
Hosting	You know where it runs, who pays, who sets it up and who maintains it
Build hours	Every line item in the worksheet has a number, even if it’s zero
Error handling	An error workflow and a named alert recipient are in the estimate
AI and approvals	Any AI step has output checks; anything sent to customers has a human check
Price	Build hours × floor × 1.25, rounded up, quoted as one flat price
Scope	Included list, one fixes round, and re-quote triggers are in writing
Handoff	Runbook, export and ownership plan are part of the build, not extra

Copy-Paste n8n Quote Template

Fill the [brackets]. Keep the price as one number.

QUOTE: [workflow name] for [client]

What it does
When [trigger], the workflow [steps] and [output].
If something fails, [named person] gets an alert by [email / Slack].

Price
[price], flat, for the build described above.

Included
- Build in your n8n account ([n8n Cloud / your server])
- Error alert and testing with your real data
- One round of fixes after you test
- Short runbook, exported workflow and a walkthrough

Not included (quoted separately)
- New apps, triggers or branches not listed above
- A second round of changes
- Hosting costs (paid by you, in your name)
- Ongoing maintenance (optional retainer: [hours] per month)

Timeline
[x] working days after access to [apps] is set up.

Payment
[50%] to start, the rest on acceptance.

Scripts for the Pricing Questions Clients Ask

Short, calm, and always ending with a next step.

1. “Why does a few-step workflow cost that much?”

“The nodes are the quick part. The price covers mapping your process, connecting your accounts safely, handling errors so it doesn’t fail silently, testing it with your real data, and a round of fixes after you try it.”

2. “Can you charge per node instead?”

“I price the finished workflow, because a short workflow with a tricky app can take longer than a long simple one. You get one fixed price for exactly what we mapped, so there are no surprises.”

3. “Can you do it cheaper?”

“Yes, by doing less. If we drop [branch / AI step / second app], the price comes down to [price]. We can add it later as a second phase.”

4. “Can you just add one more thing?”

“Happy to. That’s outside what we scoped, so I’ll send a short change note with the price before I build it.”

5. “Do I need to pay for n8n?”

“That depends on where it runs. We can use n8n Cloud in your name, or host it on your own server. Either way, the account and the hosting bill are yours, so you own the setup.”

Pricing Mistakes I See (and the Fix for Each)

What most guides on n8n pricing get wrong: they hand you price ranges with no source behind them and stop there. A range can’t tell you whether your hours make that price worth taking. Your floor and your estimate can.

1. Pricing per node.
The canvas looks small, so the quote is small.
Fix: estimate every line item in the worksheet.

2. Counting only canvas time.
Mapping, credentials and handoff disappear from the quote.
Fix: fill every line, even with a zero.

3. Skipping error handling to hit a lower price.
The workflow fails silently in week three, and you get the angry call.
Fix: an error workflow and alert are part of every build.

4. Hosting it yourself without pricing it.
“Free” hosting becomes unpaid upkeep.
Fix: the client pays for and owns hosting; maintenance is a retainer.

5. Unlimited fixes.
Round four is redesigning their process for free.
Fix: one round is in the 25%. Round two is a re-quote.

6. Quoting before the discovery call.
A price from one sentence in a DM is a guess.
Fix: run the discovery call checklist, then quote in writing.

7. Promising results.
“This will save you ten hours a week” is a claim you can’t control.
Fix: promise what you deliver: a tested workflow that does what was mapped.

The 45-Minute n8n Pricing Setup

• Minutes 0 to 10: get your floor from the rate calculator. Add any platform fee.
• Minutes 10 to 25: copy the estimate worksheet and fill it in for one workflow you’ve built or practised.
• Minutes 25 to 35: run the formula. Hours × floor × 1.25, rounded up.
• Minutes 35 to 45: fill the quote template and save the five scripts somewhere you can paste them from.
• After each job: compare your estimate with the hours you actually spent, line by line, and adjust next time.

That last step is the one that makes you good at this. After a few builds of the same kind, your estimates stop being guesses.

Frequently Asked Questions

Final Thoughts

Pricing an n8n automation gets easier the moment you stop counting nodes.

Know your floor. Estimate every hour. Add 25%. Round up. Quote one price.

Every number in your quote should trace back to a line in your estimate. That’s what lets you say the price calmly, and it’s what keeps a “quick little workflow” from turning into an unpaid weekend.

Your next action:

1. Get your floor rate from the free rate calculator.
2. Fill in the estimate worksheet for the next workflow you’re asked to build.
3. Send one flat price with the quote template, with the scope and re-quote triggers in writing.

Before the next quote, run the discovery call checklist so your hours come from the client’s real process. If you’re still choosing a platform, start with Zapier vs Make vs n8n for freelancers.

Price the build. The nodes take care of themselves.

Sources

• n8n Docs: Handle errors gracefully (error workflows and the Error Trigger)
• n8n Docs: Understand executions (which executions count toward plan limits)
• n8n Docs: Choose how to use n8n (n8n Cloud vs self-hosted)
• n8n Docs: Host n8n (self-hosted install options and editions)
• n8n Docs: Human-in-the-loop for tools (human review for AI tool calls)
• n8n Docs: Export and import (workflow JSON and credential details)

These sources back the facts about how n8n works. None of them is a source for any price on this page; every dollar figure here is an illustrative example from the formula. n8n’s docs change often, so check the linked pages before you rely on a detail. Sources checked October 19, 2026.

About the Author

Omar Yousaf

Founder of Digital Solo Hub

I help beginners build practical AI freelancing skills through structured learning, portfolio development, and realistic business strategies. My focus is on helping new freelancers create sustainable income by combining AI tools with professional execution rather than shortcuts or unrealistic promises.