GoHighLevel Make.com Integration: Setup & Cost (2026)

By Dr Priya Jaganathan, GoHighLevel Certified Admin · HL Growth Partner, Australia · Updated 11 August 2026 · 8 min read

A GoHighLevel Make.com integration earns its place the moment your automation needs to talk to a system GHL has never heard of, loop through a list, or transform data before it lands on a contact record. Native Workflows are excellent at what they do — trigger on a form submission, wait, send an SMS, move an opportunity — but they are deliberately linear. Make gives you iterators, aggregators, routers, error handlers and roughly two thousand connected apps, and for most agencies the running cost lands somewhere between nothing and about AU$50 a month per client once you have sized the plan properly. If you are pushing fewer than a few thousand records a month, the Core plan at roughly US$9/month (annual billing, at time of writing) will carry you comfortably.

The trap is that Make bills per operation — renamed "credits" in late 2025, though the maths is the same for standard modules — and a badly built scenario can burn ten times the credits it needs to. I rebuild client scenarios most weeks and the pattern is nearly always the same: a polling trigger checking every minute when a webhook would do, no filter before an expensive branch, and no error handler, so failures pile up silently until someone notices leads stopped syncing three weeks ago. This guide covers both connection methods, a first scenario you can copy, honest cost maths, and the monitoring habits that stop a HighLevel Make.com integration turning into a liability.

What Make.com adds that native GHL Workflows cannot do

Before you add a subscription, be honest about whether you need one. If the job is "tag a contact, wait two days, send an email, update a pipeline stage", stay inside GHL. Native automation is free, fast and visible to your client. Reach for Make when you hit one of these walls.

Data transformation and array handling

GHL custom fields store strings. When an external system sends you a JSON array of line items, or a nested object from an inventory platform, native Workflows cannot iterate it. Make's Iterator splits the array into discrete bundles, you process each one, and an Aggregator rolls the result back into a single value you can write to a custom field or a note. This alone justifies the tool for anyone doing e-commerce, membership or booking data.

Multi-system orchestration

A real client flow rarely stops at the CRM. A new opportunity may need a row in Google Sheets, a task in ClickUp, an invoice draft in accounting software and a Slack ping to the account manager. Chaining those inside one Make scenario is far easier to maintain than five separate outbound GoHighLevel webhooks pointed at different endpoints.

Parallel branches and scheduled batch jobs

GHL's if/else steps handle most branching, so exhaust those before paying for anything. Make's Router differs in that every route runs with its own filter, error handler and retry behaviour — useful when one downstream system is flaky. Native Workflows are also event-driven only: if you need "every Monday at 7am, pull all opportunities sitting in Proposal Sent for more than 14 days and email the sales manager a summary", Make's scheduled trigger plus search modules handle it in about six modules.

GoHighLevel Make.com integration: the two connection methods

There are two supported ways to authenticate, and choosing wrong is the most common setup mistake I see.

Method 1: the official GoHighLevel LeadConnector app (OAuth)

Search "LeadConnector" or "GoHighLevel" in Make's app list. Add any module, click Create a connection, and you will be offered connection types including GoHighLevel Location OAuth 2.0 (a single sub-account) and GoHighLevel Company OAuth 2.0 (agency level). You are redirected to HighLevel, you pick the sub-account, you approve scopes, done. The app exposes modules across contacts, opportunities, calendars and events, conversations, tasks, notes, custom fields, users, products, payments and links, plus generic "Make an API Call" and instant webhook triggers.

Use OAuth when you want token refresh handled for you and a non-technical team member may need to reconnect later. The trade-off: OAuth connections are tied to the Make user who authorised them, so if that person leaves the agency, scenarios break.

Method 2: Private Integration Token plus HTTP modules

Go to Settings → Private Integrations inside the sub-account, click Create New Integration, tick only the scopes you need (contacts.readonly, contacts.write, opportunities.write and so on) and copy the token — it is shown once. In Make, use the generic HTTP module or the app's "Make an API Call" module with an Authorization: Bearer <token> header and Version: 2021-07-28.

This is my default for agency work. The token belongs to the sub-account rather than a person, scopes are least-privilege, and you can hit endpoints the packaged modules have not caught up with yet. It is also the only sensible route for newer API surfaces. If you have not set one up before, the walkthrough in our guide to GoHighLevel API private integrations covers scope selection and token rotation properly. Full endpoint reference lives in the HighLevel developer documentation.

Which to pick

OAuth for speed and for scenarios a client might maintain. Private Integration Token for anything you are going to replicate across sub-accounts, anything touching sensitive scopes, and anything you want surviving staff turnover.

Building your first scenario, step by step

The cleanest starter build is: a new contact with a specific tag in GHL triggers enrichment in an external system, then writes the result back to a custom field and advances a pipeline stage.

1. Create the inbound webhook first. In Make, add a Custom Webhook module and copy the URL. Do not use a polling trigger — polling every minute costs you credits whether or not anything happened.
2. Fire it from GHL. Build a Workflow with your trigger (Contact Tag Added, say), then a Webhook action pointed at that Make URL. Send the contact ID and email as a minimum. If you are unsure which trigger fits, the GoHighLevel workflow triggers reference lists every option and its payload behaviour.
3. Run once and determine the data structure. Click "Redetermine data structure" in Make, then trigger the Workflow with a real test contact. Make captures the payload and every downstream module can now map those fields.
4. Add a filter immediately after the trigger. Something like "email exists AND email does not contain @example.com". Filters cost nothing; the modules they prevent from running cost credits.
5. Do the work. Add your enrichment call, transformation, or third-party module. Keep it to the minimum number of modules — every module execution is one credit.
6. Write back to GHL. Use the Update Contact module, mapping the result into a custom field. Add an Update Opportunity module if you are advancing a stage.
7. Schedule and activate. Instant webhook scenarios do not need an interval. Turn scheduling on, then run five real records through before you hand it over.

One thing to standardise early: field naming. Reference GHL custom fields by their unique key, not their display name, and keep the same keys across sub-accounts so the same scenario blueprint works everywhere. Our notes on custom values and reusable snapshots explain how to bake that consistency into a snapshot before you start cloning.

Make.com pricing and true monthly cost

Make bills on credits (formerly operations). One credit is one module execution for standard modules — a scenario with six modules that runs 500 times a month costs roughly 3,000 credits. Native AI modules bill by token consumption instead, so they are harder to forecast. Figures below are approximate and taken from the Make pricing page at time of writing; check before quoting a client.

Extra credits are purchased in blocks on top of the base plan, and higher credit tiers within each plan scale the monthly price. A worked example from a client this year: a mortgage broking sub-account running four scenarios — lead enrichment, calendar sync, document-status polling and a weekly pipeline report. Roughly 900 new leads a month, seven modules per lead, gives 6,300 credits. The weekly report loops about 120 opportunities across three modules, so 1,440 more. Calendar sync adds around 800. Total near 8,500 credits — comfortably inside a 10,000-credit Pro plan at about US$16/month, or roughly AU$25. Their initial build, before I stripped a polling trigger running every minute, was consuming over 43,000 credits a month and would have needed a plan four times the price.

Make vs Zapier vs native Workflows

Zapier is easier for a client's marketing coordinator to maintain and its GHL app is mature, but it bills per task and multi-step logic gets expensive quickly. Make is cheaper per unit of work and considerably more capable with arrays, loops and error handling, at the cost of a steeper learning curve. If your team is already Zapier-fluent and the flows are simple, the comparison in our GoHighLevel Zapier integration guide will tell you whether switching is worth the retraining.

My rule of thumb: native Workflows for anything GHL can already do; Make for data transformation, scheduled batch jobs and any flow with more than three external systems; Zapier only when the client insists on maintaining it themselves and the logic is genuinely linear.

Error handling, retries and scenario monitoring

Attach an error handler to every write module

Right-click any module and add an error handler route. For transient failures — a 429 rate limit or a 502 — use the Break directive with retries enabled, which parks the bundle in the incomplete executions queue and retries on a schedule instead of dropping it. For genuine data errors, use Resume with a fallback value so the rest of the scenario still completes.

Turn on incomplete executions and sequential processing

In scenario settings, enable "Allow storing of incomplete executions". Without it, a failed bundle vanishes. Pair it with sequential processing for scenarios that write to the same contact from multiple sources, otherwise you get race conditions where two bundles overwrite each other's custom field updates.

Build a failure alert back into GHL

The habit that has saved me most: add a final error route that posts to a GHL inbound webhook, creating a task or an internal notification in the sub-account. Silent failure is the real risk with any external automation layer — the client only finds out when a lead complains. Weekly, skim the execution history and check the credit consumption graph for scenarios trending upward.

Agency patterns for multiple sub-accounts

Do not clone a scenario per client. Instead, build one scenario that receives a locationId in the webhook payload and looks up the matching Private Integration Token from a data store or Google Sheet keyed by location. One scenario, one blueprint to maintain, dozens of sub-accounts.

Where per-client scenarios are unavoidable, export the blueprint as JSON, keep it in version control alongside the corresponding snapshot, and document which custom field keys it depends on. Combine that with a disciplined tag naming convention so scenario filters can rely on tags meaning the same thing in every sub-account. Use Make's folder structure to group by client, and Teams-level roles so a VA can view execution logs without being able to edit connections.

Common mistakes to avoid

• Polling when you could webhook. A "Watch Contacts" module on a 1-minute interval costs around 43,000 credits a month doing nothing. Use GHL Workflow webhook actions to push instead.
• No filter after the trigger. Every unfiltered bundle runs every downstream module. One well-placed filter typically cuts credit consumption by half.
• Over-scoping the Private Integration Token. Ticking every scope because it is quicker gives an external platform full write access to conversations and payments. Grant only what the scenario calls.
• Mapping custom fields by display name. Rename the field in GHL and the scenario silently writes nulls. Map by unique key and test after any field change.
• Skipping error handlers on write modules. Without incomplete executions enabled, a failed contact update is gone with no record and no retry.
• Duplicating scenarios per client. Fifteen near-identical scenarios means fifteen places to patch when the API changes. Parameterise by locationId instead.

If you want your GoHighLevel and Make.com scenarios built properly — with error handling, sensible operation budgets and documentation your team can maintain — book a strategy call with the HL Growth Partner team.

Book Your Strategy Call →

Frequently asked questions

Is a GoHighLevel Make.com integration officially supported?

Yes. Make maintains a GoHighLevel LeadConnector app with OAuth 2.0 connection types at both location and company level, plus generic API call and instant webhook modules. You can also bypass the packaged app entirely and authenticate with a Private Integration Token over HTTP modules, which is fully supported by HighLevel's API v2.

How much does it actually cost per client per month?

For a single sub-account running three to six scenarios and under about 1,500 leads a month, the Core plan at roughly US$9/month (annual billing, at time of writing) is usually enough. Agencies running multiple builders generally land on Pro or Teams, around US$16–29/month. Costs only escalate when scenarios poll unnecessarily or lack filters.

Do I need Make at all, or can native Workflows handle it?

Most GHL automation should stay native — it is free, faster and visible to the client. Add Make only when you need to iterate over arrays, aggregate data, run scheduled batch jobs, or orchestrate more than about three external systems in one flow.

Should I use OAuth or a Private Integration Token?

OAuth is faster to set up and handles token refresh automatically, but it is tied to the Make user who authorised it. A Private Integration Token belongs to the sub-account, supports least-privilege scopes and survives staff changes, which makes it the better choice for agency builds you intend to replicate.

What happens if a scenario fails overnight?

With "Allow storing of incomplete executions" enabled and error handlers using the Break directive, failed bundles queue for automatic retry rather than disappearing. Add a final error route that posts to a GHL inbound webhook so a task or notification appears in the sub-account, and review the execution log weekly.

Related articles

• GoHighLevel Stripe Integration & Payments (2026)
• GoHighLevel Facebook Lead Ads Integration
• GoHighLevel Pipeline Automation
• GoHighLevel Workflow AI Action Steps