GoHighLevel API 2.0 Documentation: Complete Guide for Starter, Unlimited & Agency Pro Plans (2026)

Picture this: You're running a thriving marketing agency in Dallas, managing 30 client accounts. Your team spends hours every week manually creating contacts, updating pipelines, and syncing data between systems. Then you discover GoHighLevel's API 2.0, and suddenly those manual tasks transform into automated workflows that run while you sleep.

That's the power of understanding GoHighLevel's API documentation.

Whether you're on the $97 Starter plan experimenting with simple integrations, running a $297 Unlimited account managing multiple clients, or operating a full $497 Agency Pro business, the API 2.0 opens doors to custom automations that separate successful agencies from struggling ones.

This comprehensive guide breaks down everything you need to know about GoHighLevel API 2.0 documentation across all plan types, with real-world applications that drive actual business results.

What Are API Documents and Why Should You Care?

Let's strip away the technical jargon.

API documentation is essentially your instruction manual for connecting GoHighLevel to other software, building custom features, and automating processes that would otherwise require manual work. Think of it as the blueprint that shows developers exactly how to make different software systems talk to each other.

Here's what makes API docs valuable for your business:

Automation blueprints: Step-by-step instructions for connecting GoHighLevel to tools like n8n, Make, Zapier, and custom applications that handle repetitive tasks automatically.

Feature roadmap: Complete list of what you can control programmatically within GoHighLevel, from contact management to payment processing.

Integration possibilities: Clear documentation on connecting payment processors, calendar systems, CRM data, and communication channels without manual data transfer.

Time savings: Replace hours of manual data entry with automated workflows that execute in seconds, freeing your team to focus on client relationships.

For agencies in competitive markets like New York, Los Angeles, or Chicago, API access isn't optional anymore. It's the difference between scaling to 100 clients or staying stuck at 10.

If you're looking to leverage these automation capabilities, 👉 explore how GoHighLevel's all-in-one platform can transform your agency operations with powerful API integrations that work seamlessly across your entire tech stack.

GoHighLevel API Access Across Different Plans

GoHighLevel provides API access across all plans, but the capabilities and features differ significantly based on your subscription tier. Understanding these differences helps you choose the right plan for your automation goals.

Basic API Access (Starter $97/month & Unlimited $297/month)

Both the Starter and Unlimited plans provide Basic API access suitable for standard integrations and automation needs.

What you get with Basic API access:

• Public API Access

• Location API Keys

• Zapier Integration

• Team Calendar

• Calendar/Service

• Appointments

• Contacts

• Forms/Surveys

• Opportunities

• Tasks

• Mailgun

Starter Plan ($97/month) Specifics:

• Up to 3 sub-accounts (client workspaces)

• No white-labeling capabilities

• No rebilling options

• Standard support

Unlimited Plan ($297/month) Specifics:

• Unlimited sub-accounts for managing multiple clients

• White-label branded desktop app

• Basic rebilling on select services (pass-through at cost, no markup)

• Full chat support

Limitations (Both Plans): No OAuth 2.0 API, no agency-level endpoints (create/update locations, snapshots, user management), no rebilling with markup, no SaaS mode, no white-label mobile app, and no priority support.

Best for: Solo consultants, small to medium agencies managing client accounts, businesses needing standard CRM automation without agency-level API control.

Real-world application: A real estate agent in Austin uses Basic API access to automatically create contacts from Facebook lead ads, manage appointments, and trigger nurture campaigns through GoHighLevel's workflow builder.

Advanced API Access (Agency Pro $497/month Only)

The Agency Pro plan ($497/month) is the only plan that provides Advanced API access. This unlocks powerful agency-level endpoints not available on Starter or Unlimited plans.

What you get with Advanced API access:

Everything in Basic API, plus:

• OAuth 2.0 API

• Create a Location

• Get Location by Location Id

• Update a Location

• Load a Snapshot

• Delete Location Twilio Account

• Get all Agency Users

• Create a User

• Get User by Location

• Get Agency by User Id

• Update a User

• Get all Snapshots

• And more agency-level endpoints...

Additional Agency Pro Features:

• SaaS Mode Activation with automatic sub-account creation

• Rebilling with Custom Markup (charge clients profit margin on usage costs)

• White-Label Mobile App (iOS and Android)

• Automated Client Billing and subscription management

• Priority Support for API-related inquiries

• Enhanced Analytics and reporting

Best for: Agencies launching white-label SaaS products, consultants building vertical-specific CRM solutions, or established agencies needing full programmatic control over locations, users, and snapshots.

Real-world scenario: A business coaching company in New York built a SaaS product for fitness trainers. Using the Advanced API, they programmatically create locations when trainers sign up, load pre-built snapshots, manage user accounts, rebill usage costs with their own markup, and sync subscription data to their accounting software—all without manual intervention.

GoHighLevel Plan Comparison: API & Features Matrix

Here's a quick comparison of API access and key features across all GoHighLevel plans:

API Access Comparison:

API Level: Starter & Unlimited = Basic API | Agency Pro = Advanced API

OAuth 2.0 API: Starter = No | Unlimited = No | Agency Pro = Yes

Location Management API: Starter = No | Unlimited = No | Agency Pro = Yes (Create/Update/Get)

Snapshot API: Starter = No | Unlimited = No | Agency Pro = Yes (Load/Get All)

User Management API: Starter = No | Unlimited = No | Agency Pro = Yes (Create/Update/Get)

Agency-Level Endpoints: Starter = No | Unlimited = No | Agency Pro = Yes

Plan Features Comparison:

Sub-accounts: Starter = 3 | Unlimited = Unlimited | Agency Pro = Unlimited + Auto Creation

White-labeling: Starter = None | Unlimited = Desktop App | Agency Pro = Desktop + Mobile App

Rebilling: Starter = None | Unlimited = At Cost (No Markup) | Agency Pro = With Custom Markup

SaaS Mode: Starter = No | Unlimited = No | Agency Pro = Yes

Support: Starter = Standard | Unlimited = Full Chat | Agency Pro = Priority

SaaS Configurator API Features (Agency Pro $497 Plan Only)

When you enable SaaS mode on the $497 Agency Pro plan, GoHighLevel provides specialized API endpoints designed specifically for managing your SaaS business. These endpoints are NOT available on the $97 Starter or $297 Unlimited plans.

SaaS Configurator API capabilities:

Plan management APIs: Retrieve all configured SaaS plans with pricing and feature details programmatically.

Subscription control: Get detailed subscription status, payment provider info, and billing data for each sub-account in real-time.

Bulk operations: Enable SaaS mode across multiple sub-accounts with single API calls, dramatically reducing setup time.

Automated provisioning: Trigger plan assignments, upgrades, and renewals through automation tools without manual intervention.

Custom integrations: Connect your SaaS billing to external CRMs, accounting software, or analytics platforms for seamless data flow.

Before using SaaS Configurator endpoints, you must be on the $497 Agency Pro plan, enable SaaS Mode, create OAuth 2.0 credentials with saas/* scope, and observe the 10 requests per second rate limit.

Understanding GoHighLevel API 2.0 Migration

GoHighLevel is transitioning from API 1.0 to OAuth 2.0-based API 2.0, which will eventually become the only available API option. Here's what agencies need to know about this migration.

API 1.0 vs API 2.0: Key Differences

API 1.0 (Legacy - End of Support):

• Simple API key authentication

• No longer receiving support, though existing integrations continue working

• Limited security features

• No new endpoints being added

API 2.0 (Current Standard):

• OAuth 2.0 authentication for enhanced security

• Private Integration tokens for simplified setup

• Comprehensive scope-based permissions

• All new features and endpoints launch here first

• Better rate limiting and performance

Migration recommendation: If you're building new integrations today, use API 2.0 exclusively. If you have existing API 1.0 integrations, plan your migration now before forced transition dates arrive.

Authentication Methods in API 2.0

GoHighLevel API 2.0 offers two primary authentication approaches:

OAuth 2.0 Authentication:

• Required for marketplace apps and public integrations

• User authorization flow with access and refresh tokens

• Access tokens expire after 24 hours, requiring refresh token usage

• Granular scope permissions control exactly what your app can access

Private Integration Tokens:

• Simplified alternative to OAuth 2.0 for internal use

• Static tokens that don't require refresh flows

• Perfect for connecting GoHighLevel to n8n, Make, or custom scripts

• Create tokens in Agency Settings with specific scope permissions

When to use each: Use OAuth 2.0 when building apps for other agencies to install. Use Private Integration tokens for your own internal automations and workflows.

Complete API 2.0 Documentation Structure

The GoHighLevel API 2.0 documentation is organized into logical sections that cover every aspect of platform integration. Here's your navigation guide.

Core CRM Endpoints

Contacts API:

• Create, read, update, and delete contact records with custom field support

• Manage custom fields and contact attributes for detailed segmentation

• Add or remove tags for automated campaign triggers

• Attach contacts to campaigns and workflows programmatically

• Track tasks and notes associated with contacts for relationship management

Real automation example: A coaching agency in London uses the Contacts API with n8n to automatically create GoHighLevel contacts whenever someone books a discovery call through Calendly, pulling their information and assigning relevant tags based on their responses.

Communication Management

Conversations API:

• Send SMS, email, and call communications programmatically without manual intervention

• Retrieve message history and conversation threads for analysis

• Update conversation status and assignments to team members

• Handle inbound and outbound messaging through unified interface

Opportunities API:

• Track deals through sales pipelines automatically

• Update opportunity stages and values based on external triggers

• Create automated pipeline reports for client dashboards

• Trigger actions based on deal progression events

Real automation example: A real estate team in Sydney built an integration that updates opportunity stages in GoHighLevel based on contract status in their legal software, ensuring their pipeline always reflects actual deal progress.

Scheduling & Calendar Integration

Calendar & Events API:

• Manage calendar configurations and availability across multiple team members

• Create, update, and delete appointments programmatically

• Handle blocked time slots to prevent double-booking

• Support multiple calendar integrations for different team members or departments

• Retrieve free/busy information for intelligent scheduling

Business scenario: A dental practice in Chicago uses the Calendar API to sync appointments between their practice management software and GoHighLevel, ensuring their marketing automation always knows when patients have upcoming appointments.

Payment Processing

Payments API:

• Process transactions and manage payment integrations seamlessly

• Handle subscription creation and management for recurring revenue

• Create and manage invoices programmatically

• Generate payment links and track transaction history

• Manage coupons and discount codes for promotional campaigns

Products API:

• Create and update product catalogs without manual entry

• Manage pricing tiers and variants for different customer segments

• Handle product reviews and ratings for social proof

• Control inventory and collections programmatically

Invoice & Estimate APIs:

• Generate invoices with custom templates matching your brand

• Send invoices to clients automatically based on triggers

• Create estimates with zero-dollar values for complimentary quotes

• Track payment schedules and installments for complex billing

Advanced Features

Workflows API:

• Retrieve workflow configurations for documentation

• Trigger contacts into specific automation sequences based on behavior

• Remove contacts from workflows programmatically when conditions change

Forms & Surveys API:

• Access form submissions and survey responses for analysis

• Upload custom files through forms automatically

• Retrieve submission data for external reporting platforms

Social Media Planner API:

• Connect social media accounts across platforms

• Create and schedule posts across platforms from single interface

• Manage posting categories and tags for organization

• Retrieve posting statistics and analytics for performance tracking

Voice AI & Conversation AI:

• Manage AI agent configurations and goals for different scenarios

• Retrieve call logs and conversation data for quality assurance

• Configure agent voices and behaviors to match brand personality

API Scopes and Permissions: Security Best Practices

GoHighLevel uses granular permission scopes to control exactly what each integration can access. This security model protects client data while enabling powerful automations.

Understanding Scope Structure

Each API scope follows this pattern: resource.permission

Examples:

contacts.readonly: Read contact data only without modification ability

contacts.write: Create, update, and delete contacts with full control

calendars.readonly: View calendar configurations without changes

calendars/events.write: Create and modify appointments programmatically

Essential Scopes for Common Use Cases

For basic CRM automations:

• contacts.readonly

• contacts.write

• locations.readonly

• opportunities.readonly

For communication workflows:

• conversations.readonly

• conversations.message.write

• campaigns.readonly

For payment processing:

• payments/transactions.readonly

• invoices.write

• products.readonly

For agency-level management:

• locations.write (create/update sub-accounts)

• oauth.readonly (view installed locations)

• snapshots.readonly (access templates)

For SaaS operations ($497 Plan Only):

• saas/location.write (enable SaaS for accounts)

• saas/company.read (retrieve plan configurations)

• companies.readonly (access agency-wide data)

Best practice: Select only required scopes for better data security. Don't request full access when you only need read permissions for specific resources.

API Rate Limits and Performance Optimization

Understanding rate limits prevents failed automations and ensures reliable integrations.

Current Rate Limit Structure

GoHighLevel implements two rate limit tiers: a burst limit of 100 API requests per 10 seconds per resource, and a daily limit of 200,000 requests per day per resource.

What this means practically:

• Per resource means limits apply separately to each location (sub-account) or company (agency)

• You can make up to 100 rapid-fire requests in 10 seconds before hitting the burst limit

• After that, you're limited to an average of 10 requests per second

• The daily limit allows for approximately 2.3 requests per second sustained over 24 hours

Rate limit headers in API responses show your current usage:

• Current request count

• Limit threshold

• Time until reset

Optimization Strategies

For agencies managing multiple clients:

Stagger API calls across different times rather than batch processing everything at once. If you're syncing data for 50 clients, spread those requests over several minutes instead of firing them simultaneously.

For high-volume operations:

Implement exponential backoff when you hit rate limits. If a request fails due to rate limiting, wait progressively longer between retry attempts rather than hammering the API repeatedly.

For real-time integrations:

Use webhook events instead of polling. Rather than checking for updates every minute via API calls, let GoHighLevel push updates to your system when changes occur, dramatically reducing API usage.

Latest API Updates from GoHighLevel Changelog

GoHighLevel continuously expands API capabilities. Here are significant updates from recent releases.

Recent API Enhancements

SaaS Configurator API Expansion ($497 Plan Only):

New endpoints enable developers to retrieve all agency SaaS plans, access subscription details, and manage SaaS enablement programmatically. This allows agencies on the Agency Pro plan to build custom onboarding flows and integrate SaaS operations with external business systems.

Documents & Contracts API:

New API endpoints support listing documents, sending documents, listing templates, and sending templates, enabling automated contract workflows for agencies managing proposals and client agreements.

Invoice Settings API:

Introduced public API for invoice settings, allowing developers to view global invoice configurations programmatically, perfect for building custom billing dashboards and reporting tools.

Video Testimonials Feature:

New video testimonial collection system with API integration for managing collected video reviews, enabling agencies to programmatically display and manage client testimonials.

Enhanced Gift Cards System:

Gift card products now support custom artwork, expiry dates, and prepaid balance management with corresponding API endpoints for e-commerce automation.

LevelUp Day 2025 API Features

Bulk Prospecting API:

New prospecting tool API supports finding and qualifying multiple leads using Google Maps data, perfect for agencies building lead generation systems for local businesses.

Banner Management API:

New banner management tool enables agencies to create, customize, and deploy announcement banners across client accounts programmatically.

Enhanced Conversation AI:

Conversation AI now supports multiple calendar integrations through workflow actions, with API controls for managing bot status.

Building Your First API Integration

Let's walk through a practical example: automatically creating GoHighLevel contacts from form submissions on your website using n8n.

Prerequisites Setup

Step 1: Create your Private Integration token

• Log into your GoHighLevel agency account

• Navigate to Settings > Private Integrations

• Click 'Create' and name your integration

• Select these scopes: contacts.write, locations.readonly

• Copy the generated token immediately (you can't retrieve it later)

Step 2: Configure n8n workflow

• Create new workflow in n8n

• Add Webhook trigger node (this receives form submissions)

• Add HTTP Request node for GoHighLevel API call

Making the API Request

Endpoint: POST https://services.leadconnectorhq.com/contacts/

Headers:

Authorization: Bearer YOUR_PRIVATE_INTEGRATION_TOKEN

Content-Type: application/json

Version: 2021-07-28

Request body structure:

json
{
"locationId": "YOUR_LOCATION_ID",
"firstName": "{{ $json.firstName }}",
"lastName": "{{ $json.lastName }}",
"email": "{{ $json.email }}",
"phone": "{{ $json.phone }}",
"tags": ["website-lead", "api-created"],
"source": "website-form"
}

Testing your integration:

Send a test webhook to n8n with sample data. Check your GoHighLevel location to verify the contact was created correctly with all fields populated and tags applied.

Common troubleshooting:

401 Unauthorized: Check your token is correct and hasn't been rotated

422 Unprocessable Entity: Verify required fields (firstName, locationId) are present

429 Rate Limit: You're making requests too quickly, implement delay between calls

GoHighLevel API for Agency Automation

Agencies managing multiple clients benefit enormously from API-powered workflows that operate across all sub-accounts.

Client Onboarding Automation

Scenario: When you close a new client, automatically set up their GoHighLevel sub-account with your standard configuration.

API workflow:

1. Create new location using POST /locations/ endpoint

2. Import snapshot template via Snapshots API

3. Configure custom fields specific to client industry

4. Set up payment integration using Payments API

5. Create initial team user accounts via Users API

6. Deploy pre-built workflows and campaigns

Time saved: What takes 2-3 hours manually now runs in 5 minutes automatically.

Cross-Client Reporting

Scenario: Generate consolidated performance reports across all client accounts without logging into each one individually.

API workflow:

1. Loop through all locations using GET /locations/search endpoint

2. For each location, retrieve opportunities data

3. Pull conversation statistics and response rates

4. Gather appointment booking data

5. Compile revenue information from transactions API

6. Generate custom dashboard or PDF report

Result: Weekly agency performance reports that previously required a full-day effort now generate automatically every Monday morning.

Bulk Contact Management

Scenario: A client gives you a CSV with 10,000 contacts to import into GoHighLevel.

API workflow using n8n:

1. Parse CSV file and split into batches of 50 contacts

2. For each batch, make bulk contact creation API calls

3. Implement rate limit handling with delays

4. Log any failed imports for manual review

5. Apply bulk tags based on data segments

Efficiency gain: Upload 10,000 contacts in under an hour instead of days of manual entry.

Integrating GoHighLevel API with n8n

n8n has become the preferred automation platform for GoHighLevel power users due to its flexibility and self-hosted option.

Setting Up n8n HTTP Request Node

Base configuration:

Method: Varies by endpoint (GET, POST, PUT, DELETE)

URL: https://services.leadconnectorhq.com/ + endpoint path

Authentication: Header Auth

Header parameters:

Authorization: Bearer {{$credentials.ghlPrivateIntegration}}

Content-Type: application/json

Version: 2021-07-28

Common n8n + GoHighLevel Workflows

Lead enrichment workflow:

1. New contact created in GoHighLevel (webhook trigger)

2. Look up company information via Clearbit API

3. Update contact custom fields with enriched data

4. Add contact to appropriate campaign based on company size

Follow-up automation:

1. Opportunity moved to 'Proposal Sent' stage (webhook trigger)

2. Wait 3 days

3. Check if opportunity stage changed via Opportunities API

4. If still in same stage, send follow-up SMS via Conversations API

Calendar sync workflow:

1. Appointment created in external calendar (Calendly webhook)

2. Create corresponding appointment in GoHighLevel via Calendar API

3. Update contact record with appointment details

4. Trigger pre-appointment workflow in GoHighLevel

Why Work with a GoHighLevel Expert for API Implementation

Building reliable, scalable API integrations requires deep platform knowledge and development experience.

Here's what expert implementation provides:

Error handling and reliability: Professional integrations include comprehensive error handling, retry logic, and monitoring that prevents automations from silently failing. When something breaks at 2 AM, proper error handling means you wake up to a notification and solution plan, not a disaster.

Security best practices: Expert developers implement proper authentication management, scope limitations, and data protection that compliance regulations require. This matters especially for agencies handling healthcare, financial, or legal client data.

Scalability architecture: An integration that works for 5 clients might collapse at 50. Experts build with growth in mind, implementing efficient batch processing, proper rate limit handling, and performance optimization from day one.

Ongoing maintenance: GoHighLevel updates their API regularly. Professional partnerships include maintenance plans that keep integrations functioning smoothly through platform changes and new feature releases.

For agencies serious about scaling their operations, 👉 start your GoHighLevel journey with a 14-day free trial and discover how the right platform combined with expert API implementation can transform your business efficiency and client satisfaction.

Frequently Asked Questions About GoHighLevel API 2.0

What's the difference between API 1.0 and API 2.0?

API 2.0 uses OAuth 2.0 authentication for enhanced security, includes all new feature endpoints, and represents GoHighLevel's future API standard. API 1.0 is legacy and no longer receiving new features or support.

Can I use the API on the $97 Starter plan?

Yes, the $97 Starter plan includes basic API access for core integrations. However, advanced API capabilities, custom workflows, and SaaS features require the $297 Unlimited or $497 Agency Pro plans.

What API features are exclusive to the $497 Agency Pro plan?

The $497 Agency Pro plan exclusively includes: advanced API capabilities for custom workflows, SaaS Configurator API endpoints, automatic sub-account creation via API, rebilling with custom markup, white-label mobile app, automated client billing, and priority support for API inquiries.

Do I need coding knowledge to use the GoHighLevel API?

Not necessarily. Platforms like n8n, Make, and Zapier provide visual interfaces for building API integrations without writing code. However, complex custom integrations benefit from developer expertise.

How do I find my Location ID for API calls?

Your Location ID appears in the URL when you're logged into a specific sub-account, or you can retrieve it programmatically using the Locations API endpoint.

What happens if I exceed API rate limits?

The API returns a 429 status code. Implement exponential backoff retry logic, and consider spreading requests over time rather than batching everything at once.

Can I build a marketplace app to sell to other agencies?

Yes, you can build marketplace apps. You'll need to create an OAuth 2.0 app in the GoHighLevel marketplace, configure proper scopes, and follow their app submission guidelines.

Can I rebill clients with markup on the $297 Unlimited plan?

No. The $297 Unlimited plan allows rebilling at cost only (pass-through), meaning you can recover usage costs but cannot add a profit margin. Rebilling with custom markup is exclusively available on the $497 Agency Pro plan.

Is the API documentation open source?

GoHighLevel maintains the API documentation on GitHub where developers can submit issues and suggestions, though the repository is primarily for documentation transparency rather than community edits.

What support is available for API developers?

GoHighLevel doesn't provide setup code auditing or consultative services. Standard and Unlimited plans receive standard support, while the $497 Agency Pro plan includes priority support with faster response times for API-related inquiries. GoHighLevel also operates a developer Slack community and monthly Developer Council calls.

Can I use the API to manage multiple agencies?

Each agency requires separate API credentials. You can build tools that manage multiple agency accounts, but each needs its own authentication.

What's the most common API integration agencies build first?

Contact synchronization between GoHighLevel and their existing CRM or lead sources represents the most common starting point, followed by custom reporting dashboards.

Final Summary: Maximizing GoHighLevel API Value

The GoHighLevel API 2.0 represents a powerful toolset for agencies ready to scale beyond manual processes. Understanding the documentation differences across Starter ($97), Unlimited ($297), and Agency Pro ($497) plans enables strategic technology decisions aligned with business goals.

Key takeaways:

The $97 Starter plan and $297 Unlimited plan both provide Basic API access with endpoints for Contacts, Appointments, Calendars, Opportunities, Tasks, Forms/Surveys, and Zapier integration. The Starter plan is limited to 3 sub-accounts, while the Unlimited plan offers unlimited sub-accounts and white-label desktop app for growing agencies.

The $497 Agency Pro plan is the only plan with Advanced API access, unlocking OAuth 2.0 API, agency-level endpoints (Create/Update/Get Locations, Load Snapshots, User Management), SaaS mode with automatic sub-account creation, rebilling with custom markup, white-label mobile app, and priority support—essential for agencies building white-label software products.

The migration from API 1.0 to 2.0 is inevitable. Build new integrations on API 2.0 today and plan legacy migrations before forced transitions create urgent problems.

Successful API implementation combines technical knowledge with business strategy. While the documentation provides the 'how,' expert consultation ensures you're building the right automations for your specific situation.

Whether you're a marketing agency in New York managing 50 med spa clients, a consulting firm in London building a vertical SaaS product, or a real estate team in Melbourne automating follow-up sequences, the GoHighLevel API enables efficiency impossible through manual processes.