canonical: https://jentic.com/apis/autotask.net/autotask

# Autotask Datto Autotask PSA REST API

Datto Autotask PSA is a professional services automation platform widely used by managed service providers (MSPs) to manage tickets, contracts, time entries, billing, and resource scheduling. The REST API exposes a uniform CRUD-and-query surface across more than 200 entities - Tickets, Companies, Contacts, Contracts, Projects, Tasks, Time Entries, Invoices, Resources - with consistent /entityInformation, /query, and /{id} routes per entity. The result is over three thousand path-and-method combinations, all reachable from a single base URL once an API user is provisioned in the Autotask UI.

## For AI agents

Create and update tickets, companies, contacts, contracts, projects, time entries, and invoices in Autotask PSA, and run filtered queries against any of the 200+ entity types using the uniform /query endpoint.

## Scope

Does not handle remote monitoring and management agents, network device discovery, or end-user remote control - use for PSA workflows: tickets, contracts, time, projects, and billing only.

## Capabilities

- Create, update, and patch records across 200+ Autotask entities using their entity-specific POST, PUT, and PATCH endpoints
- Run filtered, paginated queries against any entity via `/V1.0/{Entity}/query` with a JSON filter body
- Inspect each entity's field definitions and user-defined fields via `/entityInformation/fields` and `/entityInformation/userDefinedFields`
- Retrieve a single record by ID with GET `/V1.0/{Entity}/{id}` or delete it with DELETE
- Count records matching a filter via `/V1.0/{Entity}/query/count` without retrieving the rows
- Drive ticket-management automations: create Tickets, link Notes, assign Resources, log Time Entries
- Manage commercial records: Companies, Contracts, Contract Services, Invoices, and Billing Items

## Use cases

### MSP ticket automation

Automate the creation and triage of support tickets in Autotask from monitoring tools or email parsers. POST `/V1.0/Tickets` creates the ticket with company, contact, and priority; POST `/V1.0/Tickets/query` returns existing tickets to deduplicate; POST `/V1.0/TimeEntries` logs work as the technician resolves it. The same uniform /query and /{id} pattern works for every related entity, which keeps the integration code small even with hundreds of fields.

Example prompt: POST `/V1.0/Tickets` with companyID, contactID, title, description, and priority, then POST `/V1.0/TimeEntries` against the new ticketID as work progresses

### Reporting pipeline across PSA entities

Pull billing, time, and ticket data into a data warehouse for executive reporting. `/V1.0/{Entity}/query` accepts JSON filters with date ranges, so a nightly job iterates Tickets, TimeEntries, BillingItems, and Invoices for the last 24 hours. `/entityInformation/fields` gives a stable field list per entity so the warehouse schema can be code-generated rather than hand-maintained.

Example prompt: For each entity in the report set, POST `/V1.0/{Entity}/query` with a date filter and page through the results until the response indicates no further pages

### Contract and billing reconciliation

Reconcile contract terms, billing items, and invoices to detect under-billing or missed charges. `/V1.0/Contracts/query` lists active contracts; `/V1.0/ContractServices/query` enumerates the services on each; `/V1.0/BillingItems/query` returns what was actually invoiced. A reconciliation script flags contracts where ContractServices exist without matching BillingItems for the period.

Example prompt: Query Contracts, then for each contract POST `/V1.0/ContractServices/query` and `/V1.0/BillingItems/query` and compare the result sets

### Agent-driven service desk operations

An AI agent on the service desk creates and updates tickets in Autotask without leaving the agent's chat surface. Through Jentic the Autotask API integration code, username, and secret are all stored in the credential vault, and Jentic exposes the high-frequency operations (Tickets create, Tickets query, TimeEntries create) as discoverable tools. The agent can run `/V1.0/Tickets/query/count` to size a queue before deciding whether to escalate.

Example prompt: Search Jentic for 'create an Autotask ticket', load POST `/V1.0/Tickets`, and execute it with the company and contact IDs derived from the inbound message

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/V1.0/Tickets` | Create a new ticket |
| POST | `/V1.0/Tickets/query` | Query tickets with a JSON filter |
| GET | `/V1.0/Tickets/{id}` | Retrieve a ticket by ID |
| POST | `/V1.0/TimeEntries` | Log a time entry |
| POST | `/V1.0/Companies/query` | Query companies with a JSON filter |
| POST | `/V1.0/Contracts/query` | Query contracts with a JSON filter |
| POST | `/V1.0/Tickets/query/count` | Count tickets matching a filter |
| GET | `/V1.0/Tickets/entityInformation/fields` | Inspect Ticket field definitions |

## Key resources

- **Tickets** — Create, query, update, and resolve service tickets
- **Companies** — Customer companies and their related contacts
- **Contacts** — Individual contacts associated with companies
- **Contracts and Contract Services** — Service agreements and the line items they cover
- **Projects and Tasks** — Project structure, tasks, and milestones
- **TimeEntries** — Time logged against tickets, tasks, and projects
- **Resources** — Internal users (technicians, project managers) and their availability
- **Invoices and BillingItems** — Billing detail tied to contracts and time entries
- **Appointments** — Scheduled visits and meetings

## Why Jentic

- **Setup:** Wiring Datto Autotask PSA by hand means provisioning an API user, sending three separate header values on every call (ApiIntegrationCode, UserName, and Secret), and finding the right entity path among more than three thousand method-and-path combinations behind a single base URL. Through Jentic you install once, import the Autotask PSA API from the API Directory, store those three credential values once, and your agent calls it.
- **Permission scoping:** Autotask exposes each entity as its own operation, and record ids travel as URL path parameters like `/V1.0/Tickets/{id}`, so you can pin the agent to the operations it needs, such as creating a ticket or logging a time entry. You choose which operations it may call, so destructive ones like DELETE `/V1.0/Tickets/{id}` are not included unless you add them.
- **Credential handling:** Your three Autotask values (ApiIntegrationCode, UserName, and Secret) are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create an Autotask ticket' or 'log a time entry against a contract', and Jentic returns the matching operation with its input schema so the agent calls the right entity path without enumerating every entity-specific route.

## Related APIs

- **Atera API** — Atera is an MSP-focused PSA and RMM platform with a smaller, simpler API surface
- **Freshdesk API** — Freshdesk is a help desk platform without the PSA-level contract and billing surface
- **ServiceNow API** — ServiceNow can act as the upstream IT service-management system that creates Autotask tickets

## FAQ

### What authentication does the Autotask PSA REST API use?

Autotask requires three header values on every request: ApiIntegrationCode, UserName, and Secret. The UserName is an API user created in Autotask with a specific security level; the Secret is its generated password. Through Jentic all three values are held in the credential vault and injected as headers per call so the agent never sees the raw secret.

### How do I create a ticket through the Autotask PSA REST API?

POST `/V1.0/Tickets` with a JSON body containing companyID, the responsible contactID, title, description, status, priority, and queueID. The response returns the created ticket's id, which you can use with `/V1.0/Tickets/{id}` or `/V1.0/TimeEntries` to log work against it.

### How do queries work in the Autotask PSA REST API?

Each entity exposes `/V1.0/{Entity}/query` for a JSON filter body and `/V1.0/{Entity}/query` for URL-parameter filters via GET. The body uses Filter expressions with op values like 'eq', 'gt', 'in', and supports paginated responses via the pageDetails returned alongside each result set.

### How do I list tickets modified in the last day through Jentic?

Search Jentic for 'query Autotask tickets', load POST `/V1.0/Tickets/query`, and execute it with a Filter on lastActivityDate gt the cutoff timestamp. Jentic injects ApiIntegrationCode, UserName, and Secret on the call. Get started with Jentic One, the self-hosted execution layer.

### What are the rate limits for the Autotask PSA REST API?

Autotask enforces per-API-user thresholds (broadly 10,000 calls per hour on most accounts) and returns 429 when exceeded. Treat /query as the primary read path because it returns up to 500 records per page, which is far more efficient than per-id GETs.

### Can I discover what fields exist on a given entity?

Yes. GET `/V1.0/{Entity}/entityInformation/fields` returns the standard field list with types and constraints, and `/entityInformation/userDefinedFields` returns custom fields configured in your Autotask instance. This lets integrators introspect schema rather than hardcode it.

### Can I limit what my agent is allowed to do with the Autotask PSA REST API?

Yes. Because you run Jentic One yourself, your own rules decide which Autotask operations and credentials the agent may use, and Autotask exposes each entity as its own operation so you can pin the agent to just the routes it needs, such as POST `/V1.0/Tickets` to create a ticket or POST `/V1.0/TimeEntries` to log work. Record ids travel as URL path parameters like `/V1.0/Tickets/{id}`, so you choose exactly which operations are in scope. Destructive calls such as DELETE `/V1.0/Tickets/{id}` are not available to the agent unless you deliberately add them.