The GoHighLevel developer portal brings together API documentation, Marketplace development resources, authentication guidance, and community support. Whether you're connecting your own CRM data or building an app for other agencies, here's where to start.
Learn which developer resources matter, how API access works, when to use Private Integrations versus OAuth, and how to test your first connection without breaking a live workflow.
Open Developer Portal Explore API DocsIf you've searched for the GoHighLevel developer portal, you may want to create a Marketplace app, connect an external application to the CRM, automate lead management, or understand how HighLevel's API works.
The official developer resources are useful even if you're not an experienced programmer. They help you determine whether an integration already exists, which endpoints are available, what permissions are needed, and whether a no-code tool can do the job without custom development.
This guide focuses on the practical decisions behind building with HighLevel. For the detailed endpoint reference, see our GoHighLevel API guide. For connections that don't require custom code, start with GoHighLevel integrations.
The official HighLevel developer portal is the starting point for developers building integrations and apps for the HighLevel platform.
It connects developers to resources such as the Developer Marketplace, API documentation, developer community, and support channels. Depending on your project, you may use it to register an app, understand authorization, review API operations, or get guidance when a documented endpoint appears to behave incorrectly.
The portal is not the same thing as the HighLevel account dashboard. Your normal account dashboard is where you manage your business, CRM, workflows, and customer data. The developer resources are where you learn how software can interact with the platform programmatically.
Use the official API reference to find endpoints, authentication requirements, scopes, request examples, and response formats.
Explore app development, registration, configuration, and the steps involved in distributing an integration to the intended users.
Create scoped credentials for suitable internal tools and custom connections without building a public Marketplace app.
Use the developer support portal to report a reproducible platform bug. For coding questions, the developer community and documentation are better starting points.
The API and Marketplace can support a wide range of integrations, but the available operations depend on the current endpoint documentation, permissions, and account capabilities. Always confirm that a required feature is actually exposed before planning a product around it.
Connect a website, lead form, reporting tool, or another CRM to supported HighLevel contact operations. Automate record creation, updates, and data exchange.
Build processes that combine external systems with supported HighLevel workflow actions. Use webhooks where event notifications make sense.
Use supported read endpoints to feed internal tools, dashboards, or business reports. Plan for pagination, rate limits, access controls, and data freshness.
Connect HighLevel with external scheduling, accounting, communication, or automation systems where a native app or supported API operation is available.
The exact steps depend on whether you're making a private connection for one account or building a public app for other HighLevel users. A private integration is usually the simpler route when you only need to connect your own systems.
Write down the task you want to automate, the data involved, and the account or location that should be accessed. For example, you might want to create a contact from an external form or sync supported information into a reporting tool.
Search the HighLevel Marketplace and the platform's native integrations before writing code. A supported app can save you the effort of maintaining your own API connection.
For an internal tool, review Private Integrations. For a public app that other agencies or locations will authorize, review the developer Marketplace setup and OAuth requirements. Do not use a private token as a substitute for a public app's intended authorization flow.
Open the official API reference. Identify the required endpoint, version, authentication method, scopes, request fields, and response structure.
Grant only the access needed for your integration. Keep tokens and client secrets in a secure server-side environment or secret manager. Never publish them in front-end JavaScript or a public repository.
Start with a documented read operation where possible. Confirm the account context and response. Then test create or update operations against a dedicated test record before enabling a live workflow.
Log success and failure, handle retries carefully, and make sure repeated requests won't create unintended duplicate records. Do not include secrets or unnecessary customer data in logs.
HighLevel distinguishes basic API access from advanced API capabilities. Its published API guidance lists basic API access on Starter and Unlimited plans, while Advanced API access is available on Agency Pro. Advanced access includes capabilities such as OAuth and agency-level API access that are not available in the same way on lower tiers.
Plan names, entitlements, and API capabilities can change. Confirm the current terms for your own account before committing to a project or quoting an integration to a customer.
| Project requirement | What to investigate |
|---|---|
| Connect one account to an internal tool | Basic API access and whether a Private Integration covers the required endpoints. |
| Build an app for other HighLevel users | Developer Marketplace registration, OAuth, app permissions, and applicable Advanced API access requirements. |
| Manage agency-level resources | Whether the needed operations require agency-level access and a plan that supports it. |
| Use a particular API endpoint | Its current version, scopes, account requirements, and rate limits. |
| Publish a commercial app | Marketplace distribution rules, listing requirements, app support, and any relevant commercial terms. |
For current subscription details, check the official GoHighLevel pricing page. Our GoHighLevel pricing guide and hidden costs guide can help you evaluate the broader cost of using the platform.
Private Integration Tokens and OAuth serve different integration needs. Selecting the right one at the start helps avoid security problems and unnecessary rework.
| Feature | Private Integration | OAuth app |
|---|---|---|
| Typical use | Internal tools and private connections. | Apps that users authorize for their own accounts or locations. |
| Setup | Generate a scoped token through the account interface. | Configure an app and implement the documented authorization flow. |
| Token management | Tokens are fixed until rotated or replaced; they do not automatically refresh like OAuth access tokens. | Access tokens expire and must be managed according to the OAuth flow, including refresh where supported. |
| Permissions | Choose scopes for the private integration. | Request the appropriate scopes as part of the app authorization flow. |
| Best starting point | When you need to connect your own systems. | When building an app for other users to authorize. |
Read the official Private Integrations guide and Developer Marketplace getting-started guide before choosing your approach.
HighLevel's API documentation is versioned. The version determines the request and response behavior documented for a given endpoint. It is not the same thing as your authentication method.
For new work, use the current official documentation. For an existing integration, first identify which version and credentials it uses. Then plan and test a migration instead of changing a live connection without a fallback.
Official resources:
Webhooks allow a platform to send an event notification to a configured endpoint when a supported event occurs. They can reduce the need for an external application to repeatedly ask whether something has changed.
For example, an event-driven integration might receive a supported notification, validate the event, and then call the API to retrieve additional details or update another system. The actual events available depend on HighLevel's current webhook documentation.
When implementing webhooks, consider these points:
Explore the official HighLevel webhook documentation. For ready-made integrations, see our guides to n8n and Zapier.
If you want to create an integration that other HighLevel users can install, the developer Marketplace is the relevant starting point. This involves more than getting an API request to work: the app must use the correct authorization model, handle customer data responsibly, and follow the applicable app configuration and distribution rules.
Start from the developer portal and follow the current Marketplace instructions. Configure the required app details and authorization settings.
Determine whether the app needs location-level access, agency-level access, or both where supported. Request only the permissions needed for the features you actually provide.
For an OAuth app, implement the documented authorization and token-handling flow. Protect client secrets and tokens, and validate the authorization context before processing data.
Test installation, authorization, the main feature, permission failures, and disconnection. Confirm that the app handles missing access and failed API requests without exposing customer data.
Follow the current Marketplace requirements for the intended distribution type. Prepare clear setup instructions, a privacy policy where required, useful error messages, and a process for handling customer issues.
Start with the official Developer Marketplace getting-started guide. Marketplace review, distribution, and commercial requirements may change, so verify them before estimating your launch date.
Not every API problem is a platform bug. A failed request may be caused by a missing scope, invalid credential, wrong location ID, unsupported endpoint, outdated request schema, or rate limit.
| Problem | First thing to check | Where to look |
|---|---|---|
| 401 authentication error | Credential, token format, expiry, and authorization header. | Authentication section of the endpoint docs. |
| 403 permission error | Scopes, access level, and target account or location. | Endpoint permissions and Private Integration settings. |
| 400 validation error | Required fields, data types, and request schema. | Current endpoint example and request body schema. |
| 404 endpoint or resource error | Path, resource ID, API version, and account context. | Versioned API reference. |
| 429 rate limit | Request frequency and response headers. | Current API rate-limit guidance. |
| App installation or OAuth issue | Redirect URLs, scopes, authorization flow, and app configuration. | Developer Marketplace and OAuth documentation. |
HighLevel's documentation lists API rate limits and explains that support does not provide general hands-on code development or integration auditing. If you believe you've found a platform bug after verifying your implementation, use the developer support portal.
When reporting an issue, include the endpoint, API version, timestamp, sanitized request details, and response error. Never include a live access token, client secret, or unnecessary customer information.
Developing directly against the API isn't always the best route. If your goal is to connect two apps or automate a common task, a ready-made integration or visual automation builder may be quicker and easier to maintain.
| Approach | Best for | Main trade-off |
|---|---|---|
| Native integration | Common use cases already supported by HighLevel or another platform. | Limited to the features provided by the integration. |
| Zapier | Connecting supported apps with visual automation. | Plan limits, task usage, and available triggers or actions. |
| n8n | Custom visual workflows and more flexible integrations. | Requires workflow design and possibly hosting and maintenance. |
| Direct API development | Custom applications and integrations requiring precise control. | Requires development, security, monitoring, and ongoing maintenance. |
| Marketplace app | Building a reusable integration for other HighLevel users. | Requires app setup, authorization, distribution preparation, and user support. |
For example, if you only want a new lead to enter HighLevel from a supported form tool, check native integrations first. If you need custom business rules across several systems, n8n or a direct API connection may be more appropriate. If you're building a product for other agencies, investigate the Marketplace and OAuth requirements early.
Continue with these guides:
The official developer portal is developers.gohighlevel.com. It provides access to developer resources, the Marketplace, API documentation, and support options.
The current API reference is available at marketplace.gohighlevel.com/docs/. Check the endpoint's version, permissions, request schema, and authentication requirements before implementing it.
Yes. You can use it to explore documentation and available integrations before writing code. If you only need a common automation, a native integration, Zapier, or n8n may be easier than building a custom API connection.
The required setup depends on the integration type. A private integration uses account-level configuration and a scoped token. Public Marketplace apps require the relevant developer setup and authorization process. Check the official instructions for your project.
HighLevel distinguishes basic API access from advanced capabilities. Its published guidance lists basic access on Starter and Unlimited, and Advanced API access on Agency Pro. Confirm current plan entitlements before building or purchasing a plan for a specific integration.
Private Integrations are generally suited to internal tools and private connections. OAuth is designed for apps where users authorize access. Select the approach that matches your project and the current HighLevel requirements.
API v1 reached end of support on December 31, 2025. Existing connections may continue to work, but they no longer receive support or updates. Review the official migration guide and test replacements before retiring an existing integration.
Yes. Start from the developer portal to find the current community resources. These can be useful for implementation questions and sharing ideas with other developers.
HighLevel states that its support team does not provide general hands-on API coding or developer consulting. Review the documentation and community resources first. If a correctly configured request appears to reveal a platform bug, submit a report through the developer support portal.
You can investigate the Developer Marketplace and its available distribution options, but commercial availability depends on the app type, applicable Marketplace requirements, and current terms. Read the latest app setup and distribution documentation before developing a paid product.
If you're evaluating HighLevel for your business or agency, explore the platform before committing to a custom integration. Start with the features you need, confirm which plan supports your intended API access, and decide whether native tools or custom development offer the better fit.
Explore GoHighLevelReview current pricing, features, API entitlements, and terms before signing up.
The GoHighLevel developer portal is the best starting point for understanding the platform's APIs, building integrations, and exploring Marketplace app development. Its documentation helps you choose the correct endpoint, authorization method, scopes, and version before writing code.
If you're connecting your own systems, investigate Private Integrations first. If you're building an app for other HighLevel users, review the Developer Marketplace and OAuth requirements. If you simply want to automate a common task, check native integrations or visual automation tools before taking on the cost of custom development.
Most importantly, use the current documentation rather than relying on old API tutorials. With API v1 no longer supported and newer API versions available for supported endpoints, version selection, secure credentials, and careful testing are essential parts of a reliable integration.