# Service Autopilot API and MCP server

> Service Autopilot has no public API, developer portal or self-service API keys (checked 11 Oct 2026). Data moves through a two-way QuickBooks sync, a few partners the vendor picks, a Zapier trigger that only sends completed jobs out, and manual import and export; the QuickBooks sync needs the Pro or Pro Plus plan.

Business software for lawn care, landscaping, cleaning, snow removal, pest control and pool service companies: clients and leads, scheduling and routing, estimates, invoicing and payments.

## What is the Service Autopilot API?

Cotlet's Service Autopilot API exposes 14 endpoints for your own Service Autopilot account: search clients, get client, list jobs, get route, list estimates, list invoices, add client, create job, reschedule job, add job note, create estimate, send estimate, create invoice and send text. The search_clients endpoint returns find clients and leads by name, address, email or phone. Each endpoint takes simple JSON inputs like client_id, crew or limit and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Local services & SaaS](https://cotlet.dev/integrations/category/local-services-saas)
- **Endpoints:** 14 (6 read, 8 write)
- **Updated:** 2026-10-11

Service Autopilot has no public API, developer portal or self-service API keys (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Service Autopilot with 14 endpoints (6 read, 8 write): your AI agent signs in as you and does the work.

## Does Service Autopilot have an official API?

Service Autopilot has no public API, developer portal or self-service API keys (checked 11 Oct 2026). Data moves through a two-way QuickBooks sync, a few partners the vendor picks, a Zapier trigger that only sends completed jobs out, and manual import and export; the QuickBooks sync needs the Pro or Pro Plus plan.

| Task | Service Autopilot official | Cotlet |
|---|---|---|
| Search clients and see account history | No | Yes |
| Add a client or lead | Partly: Customers sync from QuickBooks; otherwise you add them in the app | Yes |
| Create and reschedule jobs | No | Yes |
| Read a crew route for a day | No | Yes |
| Create and send estimates | No | Yes |
| List unpaid invoices | Partly: Invoices and payments sync through the paid two-way QuickBooks sync | Yes |
| Create and send invoices | No | Yes |
| Text a client | No | Yes |

Sources: [Service Autopilot pricing and plan features](https://www.serviceautopilot.com/pricing/), [Service Autopilot 2-way QuickBooks sync](https://www.serviceautopilot.com/quickbooks-online/), [Service Autopilot lawn care software features](https://www.serviceautopilot.com/lawn-care-software/), [Service Autopilot Help: Zapier Integration, Completed Jobs Trigger](https://support.serviceautopilot.com/s/article/Zapier-Integration-Completed-Jobs-Trigger), [Service Autopilot Help: Two Way Texting Settings](https://support.serviceautopilot.com/s/article/Two-Way-Texting-Settings-1730407283666)

## For AI agents

```text
Service Autopilot has no public API, developer portal or self-service API keys (checked 11 Oct 2026). Data moves through a two-way QuickBooks sync, a few partners the vendor picks, a Zapier trigger that only sends completed jobs out, and manual import and export; the QuickBooks sync needs the Pro or Pro Plus plan.
Cotlet provides a hosted MCP server and REST API for Service Autopilot: 14 tools (6 read, 8 write).
Access       Request access at https://cotlet.dev/app/signup?app=service-autopilot; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/service-autopilot
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        search_clients, get_client, list_jobs, get_route, list_estimates, list_invoices, add_client, create_job, reschedule_job, add_job_note, create_estimate, send_estimate, create_invoice, send_text
Confirm      send_estimate, create_invoice, send_text (by default the user approves each call; the user can switch this off per tool, e.g. for scheduled automations)
Markdown     https://cotlet.dev/integrations/service-autopilot-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=service-autopilot (Service Autopilot is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to Service Autopilot once in a browser. An agent cannot do this step.
3. The API key goes into the MCP client or the REST call as a bearer token.

Fits: people who want a hosted Service Autopilot server that someone else maintains, including non-developers.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Session: the user signs in to Service Autopilot in a browser; Cotlet keeps only the session, AES-256 encrypted, revocable in the dashboard at any time.
Terms: the user stays responsible for following Service Autopilot's terms; Cotlet is not affiliated with Service Autopilot.
```

## What can an AI agent do in Service Autopilot?

Cotlet is best for lawn care and landscaping office managers who want an AI agent to add clients, move jobs, send estimates and chase invoices without running or fixing a server.

- **[Add a new client and set up recurring mowing](https://cotlet.dev/integrations/service-autopilot-api-mcp-server/add-client-and-recurring-job)** (runs: weekly): "Add the Hendersons from this email as a client at 12 Oak Lane, gate code 1234, and set up weekly mowing on Tuesdays with Crew 2 at $45 a visit, starting next week. Check first that they are not already in Service Autopilot as a lead." → `search_clients`, `add_client`, `create_job`
- **[Reschedule jobs after rain](https://cotlet.dev/integrations/service-autopilot-api-mcp-server/reschedule-jobs-after-rain)** (runs: daily): "Rain tomorrow: move Crew 2's mowing visits to Friday, but skip the contract clients, keep any visit that already moved this week, and text each moved client the new day." → `list_jobs`, `reschedule_job`, `send_text`
- **[Create and send estimates from site visit notes](https://cotlet.dev/integrations/service-autopilot-api-mcp-server/create-and-send-estimates)**: "Build an estimate for the Hendersons at 12 Oak Lane from my site visit notes: spring cleanup $250, 6 yards of mulch at $35 a yard, and offer edging at $60 as an option. Show it to me, then email it." → `search_clients`, `add_client`, `list_estimates`, `create_estimate`, `send_estimate`
- **Find unpaid invoices** (runs: weekly): "Which clients have invoices unpaid for more than 30 days, and how much do they owe?" → `list_invoices`
- **Text clients about tomorrow's visits** (runs: daily): "Text every client on tomorrow's schedule that the crew arrives between 8 and 10." → `list_jobs`, `send_text`

## Can Service Autopilot automations run on a schedule in n8n, Make or Zapier?

Yes. Cotlet does not replace your automation platform: it gives it a Service Autopilot connection it does not have, with the same API key as your agent. Write actions ask for your OK by default; switch that off in your dashboard for the tools you choose, for example to add a new client and set up recurring mowing, and the schedule runs on its own. Cotlet runs in the cloud, so it keeps going while your computer is off.

| Where | How to connect | How to schedule |
|---|---|---|
| Your AI agent | Add https://cotlet.dev/mcp/v1 with your API key. | A scheduled agent run, for example a Claude Code routine. |
| n8n | MCP Client node with https://cotlet.dev/mcp/v1, or an HTTP Request node to https://cotlet.dev/api/v1/service-autopilot/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/service-autopilot/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/service-autopilot/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/service-autopilot/{tool} with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 14 endpoints on this page, with parameters and example responses, can be listed without an account. Calling one returns 403 until the account has an API key with access to Service Autopilot.

### search_clients

Find clients and leads by name, address, email or phone. Access: read. REST: `POST /api/v1/service-autopilot/search_clients`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | yes | Name, street address, email or phone. |
| `type` | enum | no | client, lead or all. Default: all. |
| `limit` | integer | no | 1 to 100. Default: 25. |

Returns matching clients and leads with ID, name, service address and type. Pass client_id to get_client, create_job or create_estimate. Results hold up to 100 clients.

Example response:

```json
{
  "clients": [
    {
      "client_id": "4410382",
      "name": "Dana Henderson",
      "type": "client",
      "address": "12 Oak Lane",
      "phone": "555-0142"
    }
  ]
}
```

### get_client

Client account history: contact details, jobs, estimates, invoices and notes. Access: read. REST: `POST /api/v1/service-autopilot/get_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from search_clients. |

Returns one client with contact details, service address, recent jobs, estimates, invoices and notes, the same history the account page shows. Use it before replying to a client or billing one.

Example response:

```json
{
  "client_id": "4410382",
  "name": "Dana Henderson",
  "address": "12 Oak Lane",
  "email": "dana@example.com",
  "jobs": [
    {
      "job_id": "9827514",
      "service": "Mowing",
      "next_visit": "2026-10-13"
    }
  ],
  "estimates": [
    {
      "estimate_id": "E-20418",
      "total": "450.00",
      "status": "sent"
    }
  ],
  "invoices": [
    {
      "invoice_id": "I-70231",
      "amount": "45.00",
      "status": "paid"
    }
  ],
  "notes": [
    "Side gate code 1234"
  ]
}
```

### list_jobs

Scheduled and completed jobs in a date range, with client, address, crew and price. Access: read. REST: `POST /api/v1/service-autopilot/list_jobs`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day. |
| `to` | date | no | Last day. Default: same as from. |
| `crew` | string | no | Crew or technician name. |
| `status` | enum | no | scheduled, completed or all. Default: all. |

Lists visits in a date range, ordered by date, with client, address, crew and price. Filter by crew or by status. Pass job_id to reschedule_job or add_job_note.

Example response:

```json
{
  "jobs": [
    {
      "job_id": "9827514",
      "date": "2026-10-13",
      "client": "Dana Henderson",
      "address": "12 Oak Lane",
      "service": "Mowing",
      "crew": "Crew 2",
      "price": "45.00",
      "status": "scheduled"
    }
  ]
}
```

### get_route

A crew or technician route for one day: stops in route order with client and address. Access: read. REST: `POST /api/v1/service-autopilot/get_route`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `crew` | string | yes | Crew or technician name. |
| `date` | date | yes | Route day. |

Returns the stops of one crew on one day in the order the route is set, each with client, address, service and price. It reads the route as Service Autopilot shows it and does not change it.

Example response:

```json
{
  "crew": "Crew 1",
  "date": "2026-10-13",
  "stops": [
    {
      "order": 1,
      "client": "Dana Henderson",
      "address": "12 Oak Lane",
      "service": "Mowing",
      "price": "45.00"
    },
    {
      "order": 2,
      "client": "Lee Park",
      "address": "40 Elm Street",
      "service": "Mowing",
      "price": "60.00"
    }
  ]
}
```

### list_estimates

Estimates with client, total, date sent and status. Access: read. REST: `POST /api/v1/service-autopilot/list_estimates`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | no | Only this client. |
| `since` | date | no | Only estimates created on or after this date. |
| `limit` | integer | no | 1 to 100. Default: 25. |

Lists estimates, newest first, with client, total and whether the estimate was sent. Filter by client or creation date. Pass estimate_id to send_estimate.

Example response:

```json
{
  "estimates": [
    {
      "estimate_id": "E-20418",
      "client": "Dana Henderson",
      "total": "450.00",
      "status": "sent",
      "sent_at": "2026-10-08"
    }
  ]
}
```

### list_invoices

Invoices with client, amount, due date, paid or unpaid and days past due. Access: read. REST: `POST /api/v1/service-autopilot/list_invoices`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | unpaid, paid or all. Default: unpaid. |
| `client_id` | string | no | Only this client. |
| `since` | date | no | Only invoices dated on or after this date. |
| `limit` | integer | no | 1 to 200. Default: 50. |

Lists invoices with client, amount, due date and status. Unpaid invoices come first by default, oldest due date first. Filter by client or date. Amounts are in your account currency.

Example response:

```json
{
  "invoices": [
    {
      "invoice_id": "I-70198",
      "client": "Lee Park",
      "amount": "120.00",
      "due_date": "2026-09-05",
      "status": "unpaid",
      "days_past_due": 36
    }
  ]
}
```

### add_client

New client or lead with contact details and a service address. Access: write. REST: `POST /api/v1/service-autopilot/add_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Person or company name. |
| `address` | string | yes | Service address. |
| `email` | string | no | Client email. |
| `phone` | string | no | Mobile number. |
| `type` | enum | no | client or lead. Default: client. |
| `notes` | string | no | Gate codes, pets, special instructions. |

Creates a client or a lead with a service address and optional contact details and notes. It sends nothing to the client, so it runs without asking first and the record can be edited or removed in the app.

Example response:

```json
{
  "client_id": "4410382",
  "name": "Dana Henderson",
  "type": "client",
  "address": "12 Oak Lane"
}
```

### create_job

One-time or repeating job for a client, assigned to a crew. Access: write. REST: `POST /api/v1/service-autopilot/create_job`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from search_clients. |
| `service` | string | yes | Service name as set up in your account, e.g. Mowing. |
| `start_date` | date | yes | First visit. |
| `recurrence` | enum | no | one_time, weekly, every_other_week or monthly. Default: one_time. |
| `crew` | string | no | Crew or technician name. |
| `price` | string | no | Price per visit, e.g. 45.00. |
| `instructions` | string | no | Special instructions for the visit. |

Puts a job on the calendar for a client, one time or repeating weekly, every other week or monthly. The service name must match one set up in your account. It sends nothing to the client, so it runs without asking first; reschedule_job fixes a wrong date.

Example response:

```json
{
  "job_id": "9827514",
  "client_id": "4410382",
  "service": "Mowing",
  "recurrence": "weekly",
  "next_visit": "2026-10-13",
  "crew": "Crew 2",
  "price": "45.00",
  "status": "scheduled"
}
```

### reschedule_job

Move a scheduled visit to another day or crew. Access: write. REST: `POST /api/v1/service-autopilot/reschedule_job`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `date` | date | yes | New day. |
| `crew` | string | no | New crew or technician. Default: unchanged. |

Moves one scheduled visit to a new date, and to another crew if you name one. It changes the calendar only and one more call moves it back, so it runs without asking first.

Example response:

```json
{
  "job_id": "9827514",
  "date": "2026-10-16",
  "crew": "Crew 2",
  "status": "scheduled"
}
```

### add_job_note

Add a note to a job. Access: write. REST: `POST /api/v1/service-autopilot/add_job_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `note` | string | yes | Note text. |

Adds a text note to one job. It reaches no client and runs without asking first.

Example response:

```json
{
  "job_id": "9827514",
  "note_id": "n_3301",
  "status": "added"
}
```

### create_estimate

Estimate for a client from line items. Nothing is sent until you call send_estimate. Access: write. REST: `POST /api/v1/service-autopilot/create_estimate`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from search_clients. |
| `items` | object[] | yes | Line items, each with service, quantity and price. |
| `notes` | string | no | Message shown on the estimate. |

Creates an estimate for a client from line items and returns its total. The line items add up to the total. It sends nothing to the client, so it runs without asking first; send_estimate delivers it.

Example response:

```json
{
  "estimate_id": "E-20418",
  "client_id": "4410382",
  "total": "450.00",
  "status": "created"
}
```

### send_estimate

Email an estimate to the client. Access: write, asks the user first. REST: `POST /api/v1/service-autopilot/send_estimate`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `estimate_id` | string | yes | Estimate ID from list_estimates or create_estimate. |

Emails one estimate to the client on file. Service Autopilot lists estimates and proposals on the Pro plan. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "estimate_id": "E-20418",
  "status": "sent",
  "sent_to": "dana@example.com"
}
```

### create_invoice

Invoice a client for completed jobs, optionally emailing it right away. Access: write, asks the user first. REST: `POST /api/v1/service-autopilot/create_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from search_clients. |
| `job_ids` | string[] | no | Completed jobs to bill. Default: all unbilled completed jobs. |
| `send` | boolean | no | Email the invoice to the client. Default: false. |

Bills a client for completed jobs, all unbilled ones by default, and returns the invoice total. Set send to email it to the client. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": "I-70231",
  "client_id": "4410382",
  "jobs": 4,
  "amount": "180.00",
  "sent": true
}
```

### send_text

Text message to a client with 2-Way Texting. Access: write, asks the user first. REST: `POST /api/v1/service-autopilot/send_text`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from search_clients. |
| `message` | string | yes | Text message body. |

Sends a text to one client through Two-Way Texting, a paid add-on for Pro and Pro Plus members that the pricing page includes in Elite, so the call fails on accounts without it. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "client_id": "4410382",
  "status": "sent",
  "sent_at": "2026-10-12T17:30:00-04:00"
}
```

## How do I connect Service Autopilot to Claude Code, Codex or Cursor?

Connecting Service Autopilot takes three steps: request access, sign in to Service Autopilot once, then add one MCP server or call the REST API with the same key.

### Connect Service Autopilot to your agent.

1. **Create an account** Sign up and add Service Autopilot in the console. Your API key is there too.

2. **Sign in to Service Autopilot once** Open the connect page from the console and sign in to Service Autopilot the way you always do. We keep the session, never your password, and you can revoke it anytime.

3. **Add Cotlet to your agent** Paste the snippet for your client. The same server and key serve every app you connect, so you do this once.

   Claude Code:

```
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

   Cursor:

```
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COTLET_API_KEY}"
      }
    }
  }
}
```

   Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

4. **Ask your agent** Ask in plain words. Your agent finds the Service Autopilot tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Add the Hendersons from this email as a client at 12 Oak Lane, gate code 1234, and set up weekly mowing on Tuesdays with Crew 2 at $45 a visit, starting next week. Check first that they are not already in Service Autopilot as a lead.
```

### Call Service Autopilot from your scripts.

1. **Export your API key** Your scripts use the same API key as your agent. Keep it in an environment variable, never in your code.

```
export COTLET_API_KEY="cotlet_..."
```

2. **Call a tool** Every tool is a POST endpoint at /api/v1/service-autopilot/{tool}. Send its parameters as JSON, exactly as listed in the endpoints above.

```
curl https://cotlet.dev/api/v1/service-autopilot/create_job \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id":"4410382","service":"Mowing","start_date":"2026-10-13","recurrence":"weekly","crew":"Crew 2","price":"45.00","instructions":"Side gate code 1234, back yard first."}'
```

3. **Read the result** You get plain JSON back, ready for your script. A failed call costs nothing.

```
{
  "job_id": "9827514",
  "client_id": "4410382",
  "service": "Mowing",
  "recurrence": "weekly",
  "next_visit": "2026-10-13",
  "crew": "Crew 2",
  "price": "45.00",
  "status": "scheduled"
}
```

## Why use Cotlet for Service Autopilot?

**Built for agents**

- One MCP server for every app you connect.
- The same tools as a REST API for scripts and cron jobs.
- Works with Claude Code, Codex and Cursor.

**Your login stays yours**

- You sign in to Service Autopilot yourself. We keep only the session, encrypted with AES-256.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Pick read only, or read and write.
- Anything that reaches other people waits for your OK, unless you switch it off per tool.
- Revoke access in one click.

**Kept working for you**

- We test every integration daily.
- When Service Autopilot changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is there a Service Autopilot MCP server on GitHub?

No official or community MCP server exists for Service Autopilot, and its Zapier integration only sends completed jobs out, so Zapier or Make cannot create or change anything in it. Office staff click through the web app and retype jobs and estimates by hand.

|  | By hand (web app) | Cotlet |
|---|---|---|
| Setup | None, you already use the web app | Request access, sign in to Service Autopilot once in your browser, add one MCP server or API key |
| Reading your data | Open each client, route or invoice screen yourself | Your agent searches clients and reads jobs, routes, estimates and invoices |
| Write actions | Click through forms for every job, estimate and invoice | Jobs, reschedules, estimates and invoices from one prompt; sends reach clients only after you confirm |
| When the session expires | You log in again | Your agent gets a link to sign in again |
| When Service Autopilot changes | You relearn the screens | Our team tests it daily and fixes it; failed calls are free |
| Where it runs | Your browser, while you work | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free, paid in office hours | Free 7-day trial with 5,000 credits, then credits per call |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when Service Autopilot changes, without checking it yourself
- your agent or a script should run it on a schedule, also while your computer is off

**Pick an open-source server if**

- you are comfortable installing, updating and fixing it yourself
- you want the session to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the Service Autopilot API cost?

Free 7-day trial with 5,000 credits, no card needed. After that, the Service Autopilot API comes with the Cotlet plan, from $29 a month for 3,000 credits, with no limit on apps. Each month's credits stay valid for 3 months, so unused credits add up.

| Size | Price | Credits / month | Per credit |
|---|---|---|---|
| Solo | $29/mo | 3,000 | about $0.0097 |
| Pro | $99/mo | 12,000 | about $0.0083 |
| Agency | $299/mo | 40,000 | $0.0075 |

Each successful call uses credits for the work it takes; failed calls and timeouts cost nothing. A hard spend cap is on by default. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own Service Autopilot account.

- **Company details:** The legal name, address and registration numbers of the company behind Cotlet are in the Terms of service. [Terms](https://cotlet.dev/terms)
- **Your session:** You sign in to Service Autopilot yourself, in your browser. We keep only the session, never your password: encrypted with AES-256 in an EU vault, isolated to your account and used only when your agent calls a Service Autopilot tool you allowed. When it expires, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security)
- **Revoking access:** Disconnect Service Autopilot in your dashboard: the session is deleted and access ends at once. Actions that reach other people wait for your OK unless you switch that off per tool.
- **What we never do:** Store passwords, solve CAPTCHAs or bypass MFA.
- **Service Autopilot's terms:** You use your own Service Autopilot account and stay responsible for following Service Autopilot's terms. Cotlet is independent and not affiliated with Service Autopilot. [Terms](https://cotlet.dev/terms)
- **Contact:** Questions about the company, security or an app: [contact@cotlet.dev](mailto:contact@cotlet.dev)

## Frequently asked questions

**How do I get access?**

Request access and pick Service Autopilot. Cotlet reviews each request and emails you your API key.

**Do I need to be technical?**

No. You sign in to Service Autopilot once in your browser and paste one command into your agent, or one URL into n8n. Your agent can walk you through it. There is no server to install, update or fix.

**Is a hosted server safe? My Service Autopilot session would leave my computer.**

Cotlet keeps your Service Autopilot session encrypted with AES-256 in an EU vault, isolated to your account and used only for the tools you allow: read only, or read and write. The AI model never sees it, and you revoke it in one click. A local server keeps the same session in a file on your computer, readable by any program you run, and needs a fresh sign-in whenever it expires.

**Which Service Autopilot plan do I need?**

Cotlet works in your own office account, so it needs no API plan. Some features follow your plan: the vendor lists estimates and proposals on Pro, and Two-Way Texting is a paid add-on for Pro and Pro Plus members and included in Elite, so send_estimate and send_text work only where your account has them.

**Can my agent post or send messages in Service Autopilot without asking me?**

No. Every call to send_estimate, create_invoice or send_text waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. add_client, create_job, reschedule_job, add_job_note, create_estimate runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Service Autopilot API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call https://cotlet.dev/api/v1/service-autopilot/{tool} from the HTTP Request node.