Pricing AI Automation for Clients: A Reseller's Packaging Guide for Your AI Automation Agency
Most resellers don't lose deals because the automation is bad. They lose them because the pricing is confusing.
"How much for a chatbot?" has no good answer. The real cost depends on channels, integrations, volume, and how much human oversight the client wants. If you quote a different number every time, you end up underpricing hard projects and scaring off easy ones.
This guide shows how an AI automation agency (or any reseller of AI workflow automation) can turn custom work into packaged tiers that are easy to sell, easy to deliver, and profitable. You'll get:
- A simple model for deciding what to charge for
- Three sample tiers you can adapt
- A small pricing calculator you can run yourself
- The most common mistakes that destroy margins
Table of Contents
- Prerequisites
- Why packaging beats custom quotes
- Step 1: Know your real costs
- Step 2: Choose a pricing model
- Step 3: Build three sample tiers
- Step 4: Calculate your price
- Step 5: Define what's out of scope
- Common pricing mistakes
- Conclusion
Prerequisites
Before you start, make sure you have:
- [ ] A clear idea of the services you actually deliver (chatbots, lead capture, support automation, CRM sync, and so on)
- [ ] A rough record of hours spent on your last 2-3 client projects
- [ ] A list of your recurring tool costs (platform subscriptions, API usage, hosting)
- [ ] Basic comfort with spreadsheets or simple scripting (the examples use Python)
Why packaging beats custom quotes
Custom quotes feel flexible, but they create three problems:
- Slow sales cycles. Every prospect waits for a proposal.
- Inconsistent margins. Your pricing depends on your mood and the client's budget.
- Hard-to-scale delivery. No two projects look alike, so you can't build repeatable workflows.
Packaged tiers fix this. The client picks a level instead of negotiating a number, and you deliver against a defined scope.
Note: Packaging doesn't mean you never customize. It means customization happens inside a defined structure, usually as add-ons.
Step 1: Know your real costs
Before you set a price, list what each project costs you. Most agencies only count their time, which hides the real picture.
Cost categories
| Cost type | Examples | One-time or recurring |
|---|---|---|
| Setup labor | Discovery, workflow design, build, testing | One-time |
| Platform fees | Automation or chatbot platform subscription | Recurring |
| Usage costs | AI model/API calls, messaging fees | Recurring (variable) |
| Maintenance | Prompt tuning, bug fixes, monitoring | Recurring |
| Support | Client questions, change requests | Recurring |
The recurring items matter most. A project that looks profitable on day one can lose money by month three if usage costs grow and your fee doesn't.
Step 2: Choose a pricing model
Resellers usually pick one of three models, or a mix.
Model A: Setup fee + monthly retainer
The most common structure. The client pays once for the build, then monthly for hosting, monitoring, and improvements.
- Pros: Predictable recurring revenue, covers ongoing costs
- Cons: Clients may question paying monthly if they don't see ongoing value
Model B: Usage-based pricing
The client pays per conversation, per automated task, or per message.
- Pros: Scales with the client's results, with a low entry barrier
- Cons: Revenue is less predictable, and clients can dislike open-ended bills
Model C: Value-based pricing
You price against the outcome, such as hours saved, leads captured, or tickets deflected.
- Pros: Highest margin potential
- Cons: Requires solid measurement and a client who trusts the numbers
Practical tip: If you're starting out, begin with Model A. Add usage caps inside each tier so costs stay under control, and move toward value-based pricing once you have proof from real projects.
Step 3: Build three sample tiers
Three tiers is the sweet spot. Fewer than three removes choice; more than three creates confusion.
Here is a sample structure. The numbers are illustrative only. Adjust them for your market, costs, and the value you deliver.
Sample tier overview
| Starter | Growth | Scale | |
|---|---|---|---|
| Best for | Small businesses testing automation | Teams with steady inbound volume | Multi-channel or multi-team operations |
| Channels | 1 | Up to 3 | 3+ |
| Workflows included | 1-2 | 3-5 | 6+ |
| Integrations | Basic (email, spreadsheet) | CRM + helpdesk | Custom API + CRM + helpdesk |
| Human handoff | Basic | Rules-based | Advanced routing |
| Reporting | Monthly summary | Monthly + dashboard | Dashboard + review calls |
| Support | Priority email | Dedicated contact | |
| Sample setup fee | $500-1,500 | $2,000-4,500 | $5,000+ |
| Sample monthly fee | $150-300 | $400-900 | $1,200+ |
Define tiers as data
Keep your packages in a structured file so proposals, invoices, and internal docs all pull from one source:
tiers:
starter:
channels: 1
workflows: 2
conversations_included: 500
setup_fee: 1000
monthly_fee: 200
overage_per_conversation: 0.10
growth:
channels: 3
workflows: 5
conversations_included: 2500
setup_fee: 3000
monthly_fee: 650
overage_per_conversation: 0.08
scale:
channels: 5
workflows: 10
conversations_included: 10000
setup_fee: 6000
monthly_fee: 1500
overage_per_conversation: 0.06
Note: Overage pricing protects your margin when a client's usage grows beyond the tier. Without it, your best clients become your least profitable ones.
Step 4: Calculate your price
Work backward from cost and your target margin, so every tier earns what it should.
def monthly_price(
platform_cost: float,
est_usage_cost: float,
maintenance_hours: float,
hourly_rate: float,
target_margin: float = 0.5,
) -> float:
"""Return a suggested monthly fee for a client package."""
labor = maintenance_hours * hourly_rate
total_cost = platform_cost + est_usage_cost + labor
return round(total_cost / (1 - target_margin), 2)
# Example: Growth tier
price = monthly_price(
platform_cost=80, # platform subscription share
est_usage_cost=60, # estimated AI/API + messaging costs
maintenance_hours=3, # monitoring, tuning, small changes
hourly_rate=50,
target_margin=0.5,
)
print(price) # 580.0
How it works: total monthly cost is $290 ($80 + $60 + $150 labor). With a 50% target margin, you divide by 0.5 and get $580/month. Round it to a clean number, such as $599, and you have a defensible price.
For setup fees, use the same logic on your build hours, then add a buffer for revisions and unexpected integration issues.
Add-ons keep tiers clean
Instead of inventing a fourth tier for every special request, sell add-ons:
- Extra channel
- Extra workflow
- Custom integration
- Additional language support
- Priority support upgrade
Step 5: Define what's out of scope
Scope creep is where AI automation projects lose money. Put exclusions in writing:
- What is included: number of workflows, channels, and conversations
- What triggers an add-on: new integrations, new channels, major logic changes
- What the client must provide: content, access credentials, approvals, and timely feedback
- How changes are handled: a set number of revision rounds, then hourly or add-on pricing
## Scope Summary (example)
Included:
- 3 workflows (lead capture, FAQ, appointment booking)
- 2 channels (website chat, WhatsApp)
- 1 CRM integration
- 2 revision rounds before launch
Not included (available as add-ons):
- Additional channels
- Custom API development
- Staff training sessions
Common pricing mistakes
1. Pricing by hours only
Hourly pricing punishes you for getting faster. The better you build, the less you earn. Price the package, not the clock.
2. Ignoring variable usage costs
If AI calls or messaging fees scale with usage and your fee doesn't, growth squeezes your margin.
3. Underpricing to win the first client
A discounted first client usually stays discounted. Offer a limited pilot with a clear end date instead of a permanently low price.
4. Selling "AI" instead of outcomes
Clients don't want AI. They want fewer missed leads and faster replies. Put the result in your package descriptions.
5. No plan for maintenance
Prompts drift, APIs change, and business rules evolve. If maintenance isn't priced in, you'll absorb it for free.
6. Too many tiers
More than three packages creates decision fatigue. Keep it simple and use add-ons for edge cases.
Conclusion
Pricing AI automation doesn't need to be complicated. To recap:
- Know your real costs, including usage and maintenance, not just build time.
- Package your services into three clear tiers so clients choose instead of negotiate.
- Calculate prices from cost and margin, then sanity-check against client value.
- Protect your margin with usage caps, overage pricing, and written scope boundaries.
- Use add-ons instead of custom one-off quotes.
Whether you're launching a new AI automation agency or adding AI workflow automation to an existing service business, a clear packaging system makes you easier to buy from and easier to scale. Tools built for resellers, like Botsailor, help here by letting agencies manage multiple client accounts from one place, which makes tiered packages simpler to deliver.
How do you price your automation work today: retainers, usage-based, or something else? Share your approach in the comments.
Top comments (0)