Setup Usage-Based Pricing in GoHighLevel — Agency Rebilling

If you're running an agency or building apps on GoHighLevel, you know that one-size-fits-all pricing doesn't work. Your clients have different needs, different usage patterns, and different budgets. That's where usage-based pricing comes in—and it's one of the most powerful but underutilized features in GoHighLevel's App Marketplace.

Usage-based pricing lets you charge clients per execution, per message, or per custom event, which means your revenue scales with their actual activity. For agencies managing client accounts and developers building integrations, this model creates transparent, fair billing that keeps clients happy while maximizing your margins.

In this guide, I'll walk you through exactly how to set up usage-based pricing in GoHighLevel, configure markups and daily limits, and implement best practices for agency rebilling. Whether you're launching your first marketplace app or optimizing existing pricing, this framework will help you get it right. And if you haven't tried GoHighLevel yet, start with a free 30-day trial to see the App Marketplace in action.

What Is Usage-Based Pricing on GoHighLevel?

Usage-based pricing is a billing model where charges align directly with client activity. Instead of paying a flat monthly fee for an app or integration, your clients pay only for what they actually use. This could mean:

• Per-execution charges: Every time a workflow runs or an automation fires
• Per-message pricing: Charged for SMS, emails, or API calls sent through the integration
• Per-custom event: Billing based on specific actions defined by you (form submissions, webhook triggers, etc.)

For agencies, this model is a game-changer because it lets you pass these costs directly to your clients with markup. You maintain control over pricing, set guardrails with daily limits, and create predictable billing that doesn't surprise anyone.

How Pricing Modules Work in the App Marketplace

GoHighLevel's App Marketplace handles usage-based pricing through pricing modules—backend configurations that track charges and bill them to clients automatically.

Here's how the flow works:

1. Developer defines pricing: You set the base cost per unit (e.g., $0.01 per SMS, $0.50 per execution)
2. Client installs the app: The app gets installed into their account with your default pricing
3. Agency adds markup: If you're managing the client, you can add a percentage markup (e.g., 50% markup on SMS costs)
4. Usage gets tracked: Every execution, message, or event is logged automatically
5. Charges accumulate: Costs roll up daily, weekly, or monthly depending on your configuration
6. Billing flows: Charges appear on the client's invoice, or the agency's invoice if rebilled

The beauty here is that GoHighLevel handles all the tracking and invoicing—you just configure the rules once.

This is built into GoHighLevel. Try it free for 30 days →

Configuring Per-Execution and Per-Message Pricing

Setting up the actual pricing is straightforward. Let's break it down by use case.

For Per-Execution Pricing:

This applies to any action that runs once—a webhook trigger, a workflow execution, or an API call. In your pricing module configuration:

1. Navigate to your app's settings in the GoHighLevel App Configurator
2. Select "Usage-Based Pricing" from the pricing model dropdown
3. Choose "Per Execution" as the charge type
4. Set your base price per execution (e.g., $0.10)
5. Specify the meter or event that triggers the charge (usually a custom event you've defined)
6. Save and test with a limited rollout before going live

For Per-Message Pricing:

This is ideal for SMS, email, or any communication-based app. The setup is similar:

1. Select "Per Message" as your charge type
2. Define the cost per message (SMS typically runs $0.01–$0.05 depending on your provider)
3. Specify message types if applicable (SMS vs. email, for example)
4. Set thresholds if needed (e.g., don't charge for test messages under 10 characters)

Setting Up Markups and Daily Limits for Agency Rebilling

This is where agency rebilling gets powerful. You don't have to accept the developer's base pricing—you can add your own margin and control exposure with daily limits.

Configuring Markups:

When you install a usage-based app for a client, GoHighLevel lets you add a percentage markup to every charge. For example, if an SMS costs $0.02 and you add a 50% markup, your client pays $0.03 and you keep the difference.

To set this up:

1. Go to the app's configuration in your client's account
2. Look for "Pricing Markup" or "Agency Rebilling" settings
3. Enter your desired markup percentage (e.g., 25%, 50%, 100%)
4. Apply the markup to all charges going forward

Setting Daily Limits:

Daily limits prevent runaway charges if something goes wrong. For instance, if a client accidentally triggers thousands of executions, the daily limit stops the bleeding.

To configure:

1. In the same app settings, find "Daily Usage Cap" or "Daily Limit"
2. Set a maximum dollar amount per day (e.g., $100/day)
3. Choose what happens when the limit is reached: stop processing, alert you, or notify the client
4. Monitor limits for the first 30 days to fine-tune them

Best Practices for Transparent Charge Flow

Usage-based pricing only works if clients understand what they're paying for. Here are the practices that build trust and prevent disputes:

1. Document pricing clearly in your proposal
Before you install the app, show clients exactly what you're charging per unit. Example: "SMS: $0.02 per message after 100 free messages/month." No surprises.

2. Review invoices before they're sent
GoHighLevel gives you visibility into all charges before they post. Spot unusual spikes and investigate before the client sees the invoice. If a client sends 50,000 SMS in one day, you'll know why.

3. Set realistic daily limits from the start
A client sending 1,000 SMS per day shouldn't have a $50 daily cap. Calculate expected usage, add 25% buffer, and set that as your limit. Revisit quarterly.

4. Create a usage dashboard for clients (optional but powerful)
Some agencies build a simple Looker Studio or Metabase dashboard showing clients their daily usage and projected monthly cost. This transparency reduces support tickets by 70%.

5. Implement monthly review calls
For high-usage accounts, sit down monthly and review trends. Help clients optimize to reduce costs. This builds loyalty and positions you as a partner, not just a vendor.

6. Test extensively before going live
Use a sandbox environment or limited rollout (5–10 test accounts) to catch billing bugs before they impact real clients. Verify that charges post correctly, limits work as intended, and markups apply accurately.

Usage-based pricing in GoHighLevel is a legitimate competitive advantage. It allows you to scale revenue alongside client growth, stay transparent, and build trust. The key is setting it up thoughtfully, communicating clearly, and monitoring actively.