GoHighLevel API: Setup, Authentication, Endpoints & Integration

Developer Guide · Updated for 2026

GoHighLevel API: Connect Your CRM, Automate Tasks, and Build Custom Integrations

The GoHighLevel API lets developers connect HighLevel with websites, internal tools, automation platforms, and custom applications. You can use it to work with supported CRM data, calendars, conversations, payments, and other platform features.

This practical guide explains where to find the documentation, how authentication works, which API approach to choose, and how to test an integration without putting your live workflows at risk.

Explore GoHighLevel Jump to setup steps
Important API update: HighLevel API v1 reached end of support on December 31, 2025. Existing v1 integrations may continue to work, but they no longer receive support or updates. Private Integrations and the newer API documentation are important starting points for new work and migration planning. API v3 is available for supported endpoints, so always check the version and requirements for the specific endpoint you intend to use.

If you searched for the GoHighLevel API, you probably want to connect another tool to your CRM, add contacts automatically, retrieve customer information, trigger workflows, or build an integration that HighLevel does not provide out of the box.

You do not necessarily need to write code for every integration. HighLevel's native features, supported Marketplace apps, Zapier, and n8n can handle many common tasks. The API becomes especially useful when you need more control over how data moves between systems.

For a broader overview of available connections, read our GoHighLevel integrations guide. If you're comparing no-code automation options, see GoHighLevel Zapier integration and GoHighLevel n8n integration.

What Is the GoHighLevel API?

An API, or application programming interface, allows software systems to exchange information through defined requests and responses. Instead of copying a lead from one application into another manually, a connected application can send a supported request to HighLevel.

For example, a website could send a new lead to HighLevel after a form is submitted. An internal reporting tool could retrieve supported CRM information. An external scheduling application could communicate with supported calendar endpoints.

HighLevel exposes REST API endpoints for supported platform resources. REST requests commonly use HTTP methods such as GET to read data, POST to create a resource or perform an action, PUT or PATCH to update supported resources, and DELETE to remove resources where permitted. The exact method and request body depend on the endpoint.

How an API integration connects systems Website or form Lead capture Automation tool Zapier or n8n Custom application Internal tools Authentication Access token Required scopes Authorized request Version + endpoint HighLevel API Supported endpoints Response or error CRM · calendars · more Process response and log the result
Conceptual architecture. The real authorization flow and available data depend on your integration type and granted permissions.

What Can You Do With the GoHighLevel API?

The API documentation lists supported resources and operations. Your access depends on the endpoint, API version, authorization method, scopes, and account permissions. Do not assume every platform feature is exposed through a public endpoint.

Contacts and CRM data

Work with supported contact records, search for matching records, update details, and manage supported contact-related resources.

Calendars and appointments

Use supported calendar endpoints to work with calendar data and availability. Confirm which booking operations are available for your selected version.

Conversations and messaging

Use supported conversation or message endpoints to integrate communication workflows. Check required permissions and channel-specific restrictions.

Workflows and automation

Connect supported actions, trigger automation, or build a custom process around available endpoints and integration events.

Payments and products

Use the available payment, transaction, subscription, or product endpoints when your authorization and account support the operation.

Webhooks and event-driven apps

Receive supported event notifications and use them to start downstream actions without relying only on repeated polling.

Explore the official HighLevel API documentation for the current endpoint list, request schemas, examples, and supported versions. You can also visit the HighLevel developer portal for developer resources and community support.

GoHighLevel API v1, v2, and v3: What Is the Difference?

HighLevel's API documentation has evolved. It is important to distinguish API versions from authentication methods. A version identifies the API behavior and schema you are calling; an authentication method determines how your application obtains permission to access that API.

API or access approachWhat to knowPractical advice
Legacy API v1Reached end of support on December 31, 2025. Existing integrations may continue to run but are no longer maintained or supported.Plan a controlled migration rather than building a new integration around v1.
API v2The newer API and Private Integration migration path are documented by HighLevel. OAuth-based public integrations are also part of its developer platform.Follow the exact version and authentication requirements for each endpoint you need.
API v3Available for supported endpoints. The versioning documentation describes named versions and the request Version header.Use v3 where the endpoint documentation supports it; do not assume every endpoint has migrated.
Private Integration TokenA scoped token for connecting a private tool or internal integration to HighLevel.Choose the required permissions and keep each integration's access limited.
OAuth 2.0 appAn authorization flow suited to apps that need users or locations to grant access.Use the documented OAuth flow for the app type and endpoints you are building.

Official references:

Don't migrate by changing the version label alone. Request paths, authentication, permissions, payloads, and response structures can differ. Review the current documentation and test the new implementation independently before retiring the old connection.

Private Integration Tokens vs OAuth 2.0

One of the most important decisions is choosing how your application will receive authorization. The best option depends on whether you are connecting a private tool for your own business or building an app that other agencies and locations will authorize.

Private Integration

Best for: Internal tools, private automation, and custom integrations for a specific agency or location.

  • Create a dedicated integration for the tool.
  • Select only the scopes it needs.
  • Keep the token on the server or in a secure credential store.
  • Review access and rotate tokens according to current guidance.

Read the official Private Integration migration guide.

OAuth 2.0 app

Best for: Public apps or integrations that let different users authorize access to their own HighLevel account or location.

  • Register an app in the developer marketplace.
  • Configure the authorization and redirect URLs.
  • Request the appropriate scopes.
  • Handle authorization codes, access tokens, and refresh tokens securely.

See the official OAuth documentation.

Do not select OAuth simply because it sounds more advanced. Likewise, do not use a Private Integration Token for a public multi-customer app if the intended installation and authorization model requires an OAuth app. Match the method to the application design and HighLevel's current requirements.

How to Set Up the GoHighLevel API

The following setup is intended for someone building a private integration. Public apps have additional developer marketplace and OAuth setup requirements.

1

Define the exact task

Write down what the integration should do. For example, create a contact after a form submission, retrieve a contact for an internal dashboard, or start a workflow after a qualifying event. One clear task makes permissions and testing easier.

2

Find the correct endpoint

Open the official API reference. Find the resource and operation you need, then inspect the method, endpoint path, required parameters, request body, response schema, and version information.

3

Create the right authorization method

For a private tool, review the Private Integration setup in your HighLevel account. For a public or multi-customer app, follow the developer marketplace and OAuth documentation. Your account's available options may depend on plan and access level.

4

Choose the minimum required scopes

If the integration only needs to read contacts, do not grant write or delete access without a reason. If it must create contacts or update records, request the corresponding write permissions. Use the current scope list for the endpoint you selected.

5

Store credentials securely

Keep tokens and client secrets in a secure server-side environment or secret manager. Never put a private token in browser-side JavaScript, public GitHub code, a publicly accessible HTML page, or a client-visible configuration file.

6

Make a small test request

Start with a low-risk read operation where possible. Confirm that authentication works, the correct location is being accessed, and the response matches the documented schema before attempting a write operation.

7

Test the write operation separately

If your integration creates or updates records, use a dedicated test contact and verify the result in HighLevel. Check for duplicate contacts, incorrect field mappings, and unexpected changes before connecting the operation to live traffic.

8

Add error handling and monitoring

Handle authentication errors, permission failures, rate limits, timeouts, and validation errors. Log the request outcome without recording secrets or unnecessary customer data.

9

Document and maintain the integration

Record the endpoint version, scopes, connected account, responsible owner, and recovery procedure. Revisit the official documentation when HighLevel announces changes or retires a version.

GoHighLevel API Example: Create a Contact

The following is a simplified illustration of a server-side HTTP request. It is not a complete runnable application. The endpoint, request schema, version header, and required scopes must match the current official documentation for the operation you choose.

Conceptually, a contact-creation request includes:

  • The correct HTTP method and current documented endpoint.
  • An access token with the appropriate permissions.
  • The required API version header for that endpoint.
  • A JSON request body containing the supported contact fields.
  • Error handling that checks whether HighLevel accepted the request.
POST [current documented contacts endpoint]
Authorization: Bearer YOUR_ACCESS_TOKEN
Version: [version required by the endpoint]
Content-Type: application/json

{
  "firstName": "Jamie",
  "lastName": "Taylor",
  "email": "jamie@example.com"
}
Example only: Do not copy the bracketed endpoint or version placeholder into a live request. Open the official contacts documentation to confirm the current URL, exact JSON schema, required fields, and scopes for your chosen API version. The example values are fictional.

A successful HTTP response is only one part of the test. Open the intended HighLevel location and confirm that the contact was created with the correct details. Then test what happens if the same request is sent twice.

Why duplicate handling matters

Network timeouts can leave an application uncertain whether a request succeeded. If it blindly repeats a create request, it may create duplicate records depending on the endpoint and matching behavior. Design your integration to search or reconcile records appropriately, follow any documented idempotency support, and log the result of each attempt.

For a beginner, the safest first project is a single read request followed by a carefully tested write request. Avoid building a complex multi-step automation before you can confirm that authentication, scopes, endpoint selection, and error handling all work.

Authentication, Scopes, and API Security

Authentication proves that your application has a valid credential. Scopes determine what that credential is allowed to do. A valid token can still receive a permission error if the integration does not have the scope required by the endpoint.

HighLevel's API documentation lists scopes alongside supported operations. Read the scope requirements for each endpoint rather than selecting every available permission as a shortcut.

Security practiceWhy it matters
Use least-privilege scopesLimits what an exposed or misused credential can access.
Keep tokens server-sidePrevents visitors from inspecting page code and extracting credentials.
Separate credentials by integrationMakes it easier to revoke one tool without affecting unrelated connections.
Rotate credentials safelyReduces the impact of long-lived or exposed credentials. Follow current HighLevel guidance.
Protect logsAvoids accidentally storing tokens, personal information, or sensitive request bodies.
Verify the target locationPrevents test or production data from being sent to the wrong sub-account.
Review permissions periodicallyRemoves access that a tool no longer needs.

For public apps, follow the documented OAuth authorization-code flow and protect client secrets and refresh tokens. The exact setup depends on whether the app accesses a location or agency-level resources and which scopes the app requires.

Useful references:

GoHighLevel API vs Webhooks

API requests and webhooks solve related but different problems. An API request is usually initiated by your application when it needs to read or change data. A webhook is an event notification sent to a configured destination when a supported event occurs.

QuestionAPI requestWebhook
Who initiates the communication?Your application makes a request.The platform sends an event to your endpoint.
Typical purposeRead data, create a record, or perform a supported action.Notify another system that a supported event happened.
Does it replace the other?No. It may be used alongside webhooks.No. Your app may still need API calls to fetch details or update records.
Key implementation concernAuthentication, permissions, request schema, rate limits, and errors.Event validation, duplicate events, delivery failures, and retry handling.

For example, a webhook might notify your application about a supported contact event. Your application can then use an authorized API request to retrieve or update the relevant information. The exact event and endpoint must be supported by HighLevel's current documentation.

Read the official webhook documentation and our GoHighLevel integrations guide before deciding how to connect your systems.

Example: Send Website Leads to GoHighLevel

Suppose your business has a website form and wants each submission to appear in the HighLevel CRM. There are several ways to build the connection, and the best option depends on the form platform and how much control you need.

Example: website lead capture Website form Name and email Validate input Required fields Server-side API request HighLevel CRM record Log success or failure Handle retries without creating duplicates Keep private tokens out of browser-side form code
Illustrative flow. Use the form platform's secure server-side integration or a trusted automation service.

A reliable implementation follows this sequence:

  1. Collect the lead's information using a form that validates required fields.
  2. Send the data to a secure server-side handler or a supported automation platform.
  3. Authenticate with HighLevel using the appropriate credential and permissions.
  4. Call the documented endpoint with the required request body and version.
  5. Inspect the response and log the result without exposing secrets.
  6. Verify the contact in the correct HighLevel location.
  7. Handle retries and duplicate submissions safely.

If you don't want to maintain a custom server, check whether your form tool has a supported HighLevel integration or whether Zapier or n8n can handle the process. A native integration is usually easier to maintain than custom code for a simple workflow.

Should You Use the API, Zapier, or n8n?

Using the API directly gives you more control, but it also creates more responsibility. You must maintain authentication, code, logging, and error handling. No-code automation tools can reduce the amount of code you need to write.

OptionBest forTrade-off
Native HighLevel featuresStandard CRM and marketing tasks already supported by the platform.Less flexible when you need a custom connection.
ZapierConnecting supported apps with visual automation and relatively little code.Task costs, available actions, and app-specific limitations.
n8nMore flexible workflows and custom integrations, including API requests where needed.Requires workflow design, credential management, and potentially hosting.
Direct APICustom applications, tailored logic, or integrations that need greater control.Requires development, monitoring, security, and maintenance.

My practical recommendation: start with native HighLevel features. If they do not meet the requirement, check for an existing integration. Move to Zapier or n8n if a visual workflow is sufficient. Build a direct API integration when the extra control is worth the development and maintenance work.

Explore these related guides:

GoHighLevel API Pricing: Is It Free?

Do not assume that API access is either entirely free or always a separate paid add-on. HighLevel's published guidance distinguishes basic API access from advanced API capabilities, and access can depend on the account plan and authorization method. Check current plan entitlements with HighLevel before budgeting a project.

Even when your account includes the API access you need, a working integration may have other costs:

  • HighLevel plan: Your subscription and the specific API features available to it.
  • Developer time: Building, testing, documenting, and maintaining the connection.
  • Hosting: A server or managed platform for running custom code.
  • Automation tools: Zapier, n8n hosting, or other middleware if required.
  • External services: Any third-party app or service the integration connects to.
  • Monitoring: Logging, alerts, backups, and incident response where needed.

For the latest plan information, visit the official GoHighLevel pricing page and compare it with our GoHighLevel pricing guide and GoHighLevel hidden costs guide.

Common GoHighLevel API Errors and How to Fix Them

401 Unauthorized

What it usually means: The request lacks valid authentication or the token is expired, invalid, or being sent incorrectly.

What to check: Confirm the authorization header format, token status, OAuth refresh process where applicable, and the credential associated with the intended integration.

403 Forbidden or insufficient permissions

What it usually means: The credential is recognized, but it does not have permission to perform the requested operation or access the resource.

What to check: Review the endpoint's required scopes, granted permissions, account access level, and the location or agency context.

404 Not Found

What it usually means: The endpoint path or resource identifier may be incorrect, or the resource may not be available in the current context.

What to check: Copy the current endpoint path from the correct API documentation version. Confirm resource IDs and the location to which the request is being sent.

400 Bad Request or validation errors

What it usually means: The request body or query parameters do not match the endpoint's schema.

What to check: Review required fields, data types, supported values, JSON syntax, and the exact current request example. Avoid assuming that an older API payload works unchanged.

429 Too Many Requests

What it usually means: The request rate may have exceeded the applicable limit.

What to check: Review the documented rate limits and response headers. Use controlled retries with backoff where appropriate, and avoid repeatedly sending the same request without checking its outcome.

Requests succeed but the wrong data changes

What it usually means: The integration may be targeting the wrong location, mapping fields incorrectly, or using a stale identifier.

What to check: Verify the location ID, contact ID, field mapping, and response body. Test against a dedicated record before enabling the integration for production data.

An old API integration suddenly needs attention

What it usually means: The integration may rely on a legacy API version or an old authentication approach.

What to check: Identify the API version and credential used by each connection. Follow HighLevel's current migration guidance, build and test the replacement separately, and retire the old connection only after the replacement works.

HighLevel notes that its support team does not provide general API code auditing or hands-on developer consulting. For a persistent platform-side issue, consult the HighLevel developer support portal and include the endpoint, API version, timestamp, sanitized request details, and response error. Never submit a live secret or access token in a support ticket.

How to Migrate an Existing Legacy API Integration

If your current connection uses legacy API v1 or an older API key, treat migration as a small project. Avoid changing a working production automation before you have tested the replacement.

1

Inventory every integration

List each tool that uses the legacy credential, what it does, which location it accesses, and who maintains it. Check custom scripts, automation platforms, web forms, and scheduled jobs.

2

Map each operation to the current API

Identify the replacement endpoint, version, authentication method, scopes, and payload for each task. Do not assume the new request is identical to the old one.

3

Create the new credentials

Set up the appropriate Private Integration or OAuth app and grant the minimum required permissions. Store the new credentials securely.

4

Build a parallel replacement

Keep the old automation running while you create a separate new version for testing. Avoid editing an active legacy process in a way that could break its existing authentication or payloads.

5

Test representative scenarios

Test successful requests, missing fields, expired credentials, permission errors, duplicate events, and retry behavior. Compare the new result with the old workflow's intended outcome.

6

Switch over and monitor

Enable the replacement when testing passes. Monitor logs and results, keep a recovery plan, and disable the old automation only after confirming the new one is reliable.

Follow the official HighLevel API migration guide for the latest account-specific instructions. Its recommendations and exact screens may change as HighLevel updates its developer platform.

Frequently Asked Questions

What is the official GoHighLevel API documentation URL?

The current API reference is available at marketplace.gohighlevel.com/docs/. Use it to find endpoints, request schemas, authentication requirements, scopes, and supported versions.

Is the GoHighLevel API free?

API access depends on the account plan and the capabilities you need. Development, hosting, middleware, and third-party services may also add costs. Check current plan entitlements and any relevant usage charges before building your integration.

Can I still use GoHighLevel API v1?

HighLevel states that API v1 reached end of support on December 31, 2025. Existing integrations may continue to work, but they no longer receive support or updates. New work should follow the current API documentation and migration guidance.

Should I use API v2 or v3?

Check the documentation for the specific endpoint. API v3 is available for supported endpoints, but not every endpoint should be assumed to use v3. Use the version required by the current endpoint reference and its Version header instructions.

What is a Private Integration Token?

A Private Integration Token is used to authorize a private connection to HighLevel with selected permissions. It is useful for internal tools and private integrations. Store it securely and give it only the scopes the tool needs.

What is the difference between a Private Integration and OAuth?

A Private Integration is generally suitable for a private tool connected to a specific account or location. OAuth is used for an app authorization flow in which users grant the app access. Choose the method that matches your app type and HighLevel's current requirements.

Can I connect GoHighLevel to my website?

Yes, if the required operation is supported by the API or a suitable integration. For a custom website, send requests through a secure server-side handler or trusted integration service. Do not expose private tokens in browser-side JavaScript.

Can I use the API without coding?

Often, yes. Native integrations, Zapier, and n8n can handle many common connections. A direct API integration is most useful when you need custom logic or functionality that existing tools do not provide.

Does the API support webhooks?

HighLevel documents webhook capabilities for supported events. Webhooks can notify another application when an event occurs, while API requests can retrieve or change supported data. Many integrations use both.

Where can I get help with API errors?

Start with the endpoint documentation and HighLevel's developer support resources. Include the API version, endpoint, sanitized error response, and steps to reproduce the issue. Never share access tokens, client secrets, or unnecessary customer data.

Want to Build Your CRM and Automation in One Place?

GoHighLevel combines CRM, sales pipelines, calendars, and workflow automation. If you're considering it for your business or agency, review the current features and API access available on your plan before deciding whether to build a custom connection.

Explore GoHighLevel

Check current product terms, features, and pricing before signing up.

Final Verdict

The GoHighLevel API gives developers a way to connect supported CRM data and platform capabilities with websites, automation tools, and custom apps. The best implementation starts with one clearly defined task, the correct endpoint, secure authentication, and only the permissions required.

For a private tool, investigate Private Integrations. For a public app that needs user authorization, review the OAuth documentation. Because legacy API v1 is no longer supported and newer versions are available for supported endpoints, check the current version reference before writing code or migrating a connection.

If you only need a straightforward automation, a native integration, Zapier, or n8n may be simpler than maintaining your own API code. Use the direct API when the additional flexibility is worth the responsibility for testing, security, monitoring, and future maintenance.

Replace 100 tools with One Platform

Business platform dashboard Get Started