The ConnectWise API is the gateway to programmatic control over your PSA. Every ticket, company record, configuration item, and time entry in ConnectWise Manage is accessible through its REST API, which means anything you do manually in the interface can theoretically be automated. For MSPs looking to eliminate repetitive service desk work, that opens up significant possibilities, but it also raises a practical question: should you build custom integrations yourself, or use a platform that has already done the heavy lifting?
This guide covers the ConnectWise Manage API from an MSP operator’s perspective. We will walk through the key endpoints, common automation patterns, API limitations you need to plan around, and how AI-powered platforms like Mizo use the same API to deliver automations that go far beyond what scripts alone can achieve.
What Is the ConnectWise Manage API?
ConnectWise Manage (now part of the ConnectWise Asio platform) exposes a ConnectWise REST API that allows external applications to read, create, update, and delete records across the system. The API follows standard REST conventions with JSON payloads and supports both API key authentication and member impersonation.
The base URL follows the pattern:
https://api-na.myconnectwise.net/v4_6_release/apis/3.0/ConnectWise documents over 700 endpoints organized across modules like Service, Company, Finance, Project, and System. For MSP automation, only a subset of these matter on a daily basis.
If you have worked with the Autotask API, you will notice some similarities in structure, but ConnectWise offers broader endpoint coverage and a more flexible authentication model. The trade-off is that ConnectWise’s data model is more complex, which means more setup work for custom integrations.
Key API Endpoints for MSP Service Desk Automation
Not all 700+ endpoints are relevant to service desk operations. Here are the ones that matter most for ticket lifecycle automation:
Service Tickets
The /service/tickets endpoint is the workhorse. It supports full CRUD operations on tickets, including:
- Creating new tickets with type, subtype, item, board, status, priority, and company assignment
- Updating ticket fields like status, priority, assigned resource, and custom fields
- Querying tickets with conditions (e.g., all open tickets on a specific board older than 24 hours)
- Adding notes and internal/external communications
Common query example: Pull all open tickets assigned to a specific member where the SLA deadline is within the next two hours. This kind of targeted query powers proactive escalation workflows.
Service Boards and Statuses
Boards organize tickets by function (e.g., “Help Desk,” “Projects,” “Alerts”), and each board has its own set of statuses. The /service/boards and /service/boards/{id}/statuses endpoints let you:
- List available boards and their configurations
- Read status workflows to understand valid transitions
- Route tickets to the correct board programmatically
Understanding board-status relationships is critical for ConnectWise automation. Moving a ticket to the wrong board or setting an invalid status will throw API errors.
Members and Resources
The /system/members endpoint provides access to technician records, including:
- Skill sets and certifications
- Work roles and work types
- Calendar availability
- Security roles (important for impersonation)
This data feeds dispatch and routing logic when you need to assign tickets based on technician skills and workload.
Companies and Contacts
The /company/companies and /company/contacts endpoints are essential for contextual automation. Knowing which company submitted a ticket, their service tier, and their primary contact helps automate:
- Priority escalation for premium clients
- Agreement matching for billing
- Client-specific routing rules
Configurations (Assets)
The /company/configurations endpoint connects tickets to specific assets, which is valuable for:
- Identifying recurring issues on specific hardware or software
- Enriching tickets with asset context before a technician reviews them
- Triggering automated responses for known configuration issues
Common Automation Patterns Using the ConnectWise API
Here are the patterns MSPs most frequently build using the ConnectWise Manage API:
1. Automated Ticket Creation from External Sources
Ingest alerts from RMM tools, email parsers, or monitoring systems and create properly categorized tickets via the API. This eliminates manual ticket entry and ensures every alert gets tracked.
2. Status-Based Workflow Triggers
Poll for tickets that hit a specific status (e.g., “Waiting on Client” for more than 48 hours) and automatically update them, send follow-up notifications, or escalate.
3. Board Routing Based on Ticket Content
Parse the ticket summary and description to determine the correct service board. A ticket mentioning “firewall” routes to the Network board. One mentioning “QuickBooks” routes to the Application Support board.
4. Time Entry Automation
Use the /time/entries endpoint to log time automatically when ticket status changes, reducing the manual time-tracking burden that technicians frequently skip.
5. Reporting and Analytics
Pull ticket data in bulk to build custom dashboards that track metrics like first-response time, resolution time by category, and technician utilization, metrics that ConnectWise’s built-in reporting may not surface the way you need.
6. Agreement and SLA Matching
Query active agreements for a company and attach the correct one to incoming tickets. This is one of the most time-consuming manual steps in ConnectWise and a prime candidate for automated ticket triage.
API Capabilities and Limitations
Before you start building, here are the practical realities of working with the ConnectWise REST API:
Authentication
ConnectWise uses a compound API key system: a public key and private key pair, plus a client ID (obtained from the ConnectWise Developer Portal). Authentication is passed via the Authorization header using Basic auth encoding of company+publicKey:privateKey.
Member impersonation allows API calls to execute as a specific user, which is important for audit trails and permission scoping.
Rate Limits
ConnectWise does not publish hard rate limit numbers in the same way Autotask does (which enforces a strict per-minute threshold). However, aggressive polling or high-volume batch operations can trigger throttling. Best practice is to implement exponential backoff and use webhooks where possible instead of polling.
Pagination
The API returns a maximum of 1,000 records per request. For larger datasets, you need to implement pagination using page and pageSize parameters. Forgetting pagination is one of the most common mistakes in custom ConnectWise scripts.
Webhooks (Callbacks)
ConnectWise supports callback entries that notify external URLs when specific events occur (e.g., ticket created, ticket status changed). This is significantly more efficient than polling and is the preferred approach for real-time automation. Configure callbacks via /system/callbacks.
Conditions and Filtering
The API supports a conditions parameter that allows SQL-like filtering on most GET requests. For example:
conditions=status/name='New' and board/name='Help Desk'This filtering capability is powerful but has its own syntax quirks that require testing.
ConnectWise API vs AI-Powered Integration
Here is where things get interesting. The ConnectWise API gives you access to data and the ability to move it around. What it does not give you is the ability to understand that data. That distinction is the gap between raw API scripting and an AI-powered integration.
| Capability | Raw ConnectWise API | AI Layer (e.g., Mizo) |
|---|---|---|
| Read/write ticket data | Yes | Yes (via the same API) |
| Route based on keywords | Manual regex/rules | NLP-based intent analysis |
| Understand ticket context | No | Yes, cross-references client history, assets, and documentation |
| Predict priority and impact | No | Yes, based on historical patterns and SLA data |
| Handle ambiguous tickets | Fails or misroutes | Resolves using contextual reasoning |
| Adapt to new issue types | Requires new code | Learns from new data automatically |
| Agreement matching | Custom query logic required | Automatic, multi-factor matching |
| Setup time | Weeks to months | Under one hour |
| Maintenance burden | Ongoing development | Managed by platform |
| Scalability | Limited by developer capacity | Scales with ticket volume |
The API is the foundation either way. The difference is whether you are writing the intelligence layer yourself or using one that already exists. For a deeper look at how this plays out across PSA platforms, see our comparison of AI automation across ConnectWise, Autotask, and HaloPSA.
Security Considerations
API access to your PSA is a serious matter. ConnectWise Manage holds client data, financial records, and infrastructure details. Here are the security practices you should follow:
- Scope API keys narrowly. Create dedicated integrator accounts with only the permissions needed for each integration. Do not use an admin-level API key for a script that only needs to read tickets.
- Use member impersonation carefully. Impersonation is useful for audit trails but also means the API key holder can act as any member. Restrict which members can be impersonated.
- Rotate keys regularly. Treat API keys like passwords. Rotate them on a schedule and revoke keys for integrations you no longer use.
- Encrypt in transit and at rest. All API traffic should use HTTPS (ConnectWise enforces this). Store API keys in a secrets manager, not in plaintext config files or source code.
- Monitor API usage. Track which integrations are making calls, how frequently, and what data they access. Anomalous patterns may indicate a compromised key.
When you use a managed platform like Mizo, these security practices are handled at the platform level, including credential encryption, least-privilege access, and audit logging.
Build vs Buy: Custom ConnectWise Scripts vs Platforms Like Mizo
The build-vs-buy decision comes down to three factors: time to value, maintenance cost, and capability ceiling.
Building custom scripts makes sense when:
- You have a single, narrow automation need (e.g., auto-close stale tickets)
- You have in-house development talent with ConnectWise API experience
- You want full control over every line of logic
Using a platform makes sense when:
- You need intelligent triage and dispatch, not just data movement
- You want automation that understands ticket content, not just ticket fields
- You do not want to maintain custom code as ConnectWise updates its API
- You need to be operational in days, not months
Most MSPs we work with started with custom scripts. A PowerShell script here, a Python webhook handler there. Over time, those scripts accumulate technical debt. The ConnectWise API changes, edge cases multiply, and the person who wrote the original script leaves the company. The “free” solution becomes the most expensive one.
Mizo uses the same ConnectWise REST API under the hood but adds the decision-making layer that scripts cannot replicate. Natural language understanding, historical pattern matching, multi-factor routing, and automated triage and dispatch that handles the full ticket lifecycle from arrival to resolution.
Get Started
The ConnectWise API is powerful infrastructure. But infrastructure without intelligence is just plumbing. If you want to see what the API can do when paired with AI that actually understands your tickets, your clients, and your workflows, book a demo with Mizo and we will show you the difference in your own ConnectWise environment.