Managing marketplace apps in GoHighLevel can quickly become a performance drain if you're not actively cleaning up dormant accounts and unnecessary webhook subscriptions. When users uninstall your app—or when accounts go inactive—those webhooks keep firing, consuming resources and slowing down both your infrastructure and your users' systems. This is where the App Uninstall API becomes a game-changer for developers and agencies.
In this guide, I'll walk you through exactly how to implement GoHighLevel's App Uninstall API to automatically clean up user data, eliminate dead webhook activity, and optimize your app's overall performance. Whether you're managing a single marketplace app or running multiple integrations across client accounts, this approach will save you time and reduce operational overhead. Plus, if you haven't explored GoHighLevel's full platform yet, you can try it free for 30 days—that's double the standard trial period.
What Is the App Uninstall API and Why You Need It
The App Uninstall API is a developer tool within GoHighLevel that allows you to programmatically remove your application from user accounts—whether those accounts are agency-level or sub-accounts. Think of it as the cleanup crew for your marketplace app.
When a user uninstalls your app or when their account becomes dormant, you have two choices: leave the integration hanging around consuming resources, or use this API to properly remove all traces of the app from their account. The second option is smarter.
Why this matters: Every webhook your app has registered continues firing events even if the user isn't actively using your integration. A single dormant account might trigger dozens of webhook calls per day. Multiply that across hundreds of users, and you're burning server resources and API quota for activity that generates zero value. The App Uninstall API lets you shut this down cleanly.
Beyond performance, proper uninstallation also demonstrates professionalism and builds trust with agencies and end-users. When an app cleanly removes itself—deleting its data, canceling subscriptions, and stopping all background activity—users feel confident they're working with a well-engineered solution.
How App Uninstall API Reduces Webhook Activity
Webhooks are the backbone of modern API integrations. Your app listens for events in GoHighLevel—a contact is created, a campaign launches, a payment is processed—and reacts accordingly. This is powerful, but it assumes the user is actively engaged.
The webhook problem: When a user uninstalls your app, those webhook subscriptions often remain active in the background. The GoHighLevel system continues sending events to your endpoint. If you're not receiving them, you might log errors. If you are receiving them, you're processing data for an account that's no longer a customer. Either way, it's waste.
The App Uninstall API solves this by allowing you to:
- Deregister all webhooks associated with that app installation
- Remove stored data about the user or their account from your database
- Cancel any active subscriptions or billing cycles
- Log the uninstall event for compliance and business intelligence
This cleanup happens automatically or on-demand, depending on how you configure it. The result: lower server load, cleaner data, and reduced API costs.
💡 Pro Tip
Set up an automated cleanup job that runs daily. Query your database for app installations that haven't triggered a webhook in 90 days, then call the App Uninstall API to remove them. This keeps your data lean and your performance fast without requiring manual intervention.
This is built into GoHighLevel. Try it free for 30 days →
Step-by-Step Setup Instructions
Step 1: Access the GoHighLevel API Documentation
Navigate to the GoHighLevel API v2 documentation (available on the HighLevel GitHub repository). You'll need to locate the "Uninstall Application" endpoint. This is where you'll find the exact request format and authentication requirements.
Step 2: Authenticate with Your API Key
The App Uninstall API requires authentication via your GoHighLevel API key. Make sure your API credentials have the appropriate permissions to uninstall apps from locations and sub-accounts. If you're working within your own marketplace app, GoHighLevel will handle some of this automatically, but verify your key has the app:write scope or equivalent.
Step 3: Build Your Uninstall Request
A basic uninstall request targets either a company (agency) or a specific location. The endpoint typically looks like:
DELETE /locations/{locationId}/apps/{appId}
Or at the company level:
DELETE /companies/{companyId}/apps/{appId}
Include your API key in the Authorization header and execute the request. The API will return a 200 or 204 status to confirm the uninstall completed successfully.
Step 4: Verify Webhook Removal
After calling the uninstall endpoint, verify that all webhooks for that account have been removed. Query the webhook management endpoint to ensure no subscriptions remain. This confirms the cleanup was thorough.
Step 5: Implement Error Handling
Not every uninstall request will succeed immediately. Network issues, rate limiting, or conflicting permissions might cause failures. Wrap your API calls in try-catch blocks and implement retry logic with exponential backoff. Log every attempt—both successes and failures—for audit purposes.
Best Practices for Webhook Management
1. Implement Uninstall Callbacks in Your App UI
When a user clicks "Uninstall" in the GoHighLevel marketplace or in your app settings, that action should trigger your backend to call the App Uninstall API. Don't rely on manual processes or hope that webhooks will eventually stop firing.
2. Use Uninstall Webhooks from GoHighLevel
GoHighLevel itself can send you an uninstall webhook when a user removes your app. Subscribe to this event and use it as the trigger to clean up your database. This ensures you're always in sync with the user's actual installation status.
3. Monitor Webhook Latency and Failures
Set up alerts for webhook delivery failures. If you're receiving 4xx or 5xx responses from GoHighLevel's webhook delivery attempts, investigate and fix the issue. Failing webhooks waste resources and create data inconsistencies.
4. Implement Rate Limiting on Your End
Even though GoHighLevel manages their own rate limits, you should implement throttling on your webhook endpoint. If a burst of events arrives, queue them for processing instead of trying to handle them all instantly. This prevents cascading failures.
5. Maintain a Webhook Audit Log
Log every webhook received, every uninstall API call made, and every deletion performed. This creates a clear paper trail for debugging issues and satisfying compliance requirements. Include timestamps, user IDs, and response codes.
Monitoring and Optimizing Performance
Once you've set up the App Uninstall API, don't set it and forget it. Performance optimization is ongoing.
Track Your Webhook Volume
Monitor how many webhooks your app receives daily. After implementing the App Uninstall API and cleaning up dormant accounts, you should see this number decline noticeably. If it doesn't, you may have orphaned webhook subscriptions that need manual cleanup.
Measure Response Times
Use GoHighLevel's API dashboard (if available) or your own logging to track how long webhook processing takes. As you remove dead accounts, your average response time should improve. If it doesn't, the bottleneck lies elsewhere—perhaps in your database queries or third-party API calls.
Set Up Alerts for Uninstall Failures
If the App Uninstall API call fails for any reason, get notified immediately. You might be hitting rate limits, or there might be a permission issue preventing proper cleanup. Early detection prevents the problem from compounding.
Review Uninstall Metrics Monthly
How many apps are you uninstalling each month? What percentage of users are uninstalling? High uninstall rates might indicate product-market fit issues worth investigating. Low uninstall rates combined with low usage might mean you need better dormancy detection logic.
The App Uninstall API is one of those tools that doesn't seem critical until you've lived without it—then you can't imagine going back. By implementing it properly, you're not just optimizing your infrastructure; you're also demonstrating to users that you take their data and account security seriously.