# Knowify API and MCP server

> Knowify has no public REST API (checked 11 Oct 2026). Its official AI Connector (MCP) lets users with admin permissions ask questions about jobs, billing, labor and collections, and is read-only for now. Its Zapier app creates jobs, clients, bills and tasks. Neither creates invoices, sends proposals or logs time.

Job management and job costing software for trade contractors: bids, contracts, change orders, invoicing, time tracking and QuickBooks sync.

## What is the Knowify API?

Cotlet's Knowify API exposes 15 endpoints for your own Knowify account: list jobs, get job, get job cost, list invoices, list clients, list time entries, create client, create job, save proposal, send proposal for signature, add change order, create invoice, send invoice, record payment and log time. The list_jobs endpoint returns contract jobs with client, contract status, revenue, cost and profitability. Each endpoint takes simple JSON inputs like job_id, search or name and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Invoicing & freelance CRM](https://cotlet.dev/integrations/category/invoicing-freelance-crm)
- **Endpoints:** 15 (6 read, 9 write)
- **Updated:** 2026-10-11

Knowify has no public REST API (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Knowify with 15 endpoints (6 read, 9 write): your AI agent signs in as you and does the work.

## Does Knowify have an official API?

Knowify has no public REST API (checked 11 Oct 2026). Its official AI Connector (MCP) lets users with admin permissions ask questions about jobs, billing, labor and collections, and is read-only for now. Its Zapier app creates jobs, clients, bills and tasks. Neither creates invoices, sends proposals or logs time.

| Task | Knowify official | Cotlet |
|---|---|---|
| Job cost to date vs budget | Partly: AI Connector answers questions, admins only | Yes |
| Create a contract job | Yes: Zapier action Create Contract Job | Yes |
| Save a proposal with line items | No | Yes |
| Send a proposal for e-signature | No | Yes |
| Add a change order | No | Yes |
| Create and email an invoice | No | Yes |
| Record a client payment | No: Zapier has a New Invoice Payment trigger only | Yes |
| Log time on a job phase | No | Yes |

Sources: [Getting started with the Knowify AI Connector](https://knowify.zendesk.com/hc/en-us/articles/49623682048660-Getting-started-with-the-Knowify-AI-Connector), [Knowify AI Connector](https://knowify.com/ai/mcp-server/), [Knowify triggers and actions on Zapier](https://zapier.com/apps/knowify/integrations), [Knowify integrations](https://knowify.com/integrations/)

## For AI agents

```text
Knowify has no public REST API (checked 11 Oct 2026). Its official AI Connector (MCP) lets users with admin permissions ask questions about jobs, billing, labor and collections, and is read-only for now. Its Zapier app creates jobs, clients, bills and tasks. Neither creates invoices, sends proposals or logs time.
Cotlet provides a hosted MCP server and REST API for Knowify: 15 tools (6 read, 9 write).
Access       Request access at https://cotlet.dev/app/signup?app=knowify; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/knowify
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_jobs, get_job, get_job_cost, list_invoices, list_clients, list_time_entries, create_client, create_job, save_proposal, send_proposal_for_signature, add_change_order, create_invoice, send_invoice, record_payment, log_time
Confirm      send_proposal_for_signature, create_invoice, send_invoice, record_payment (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/knowify-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=knowify (Knowify is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to Knowify 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 Knowify 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 Knowify 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 Knowify's terms; Cotlet is not affiliated with Knowify.
```

## What can an AI agent do in Knowify?

Cotlet is best for trade contractors and their office staff who want an AI agent to create jobs, bill progress, log time and check job costs in Knowify without running or fixing a server.

- **[Weekly report of job phases over budget](https://cotlet.dev/integrations/knowify-api-mcp-server/weekly-job-cost-report)** (runs: weekly): "Every Monday at 7, list the active Knowify jobs with a phase over budget or above 90% of its budget, biggest overrun first." → `list_jobs`, `get_job_cost`, `list_time_entries`
- **[Create a job and send the proposal for e-signature](https://cotlet.dev/integrations/knowify-api-mcp-server/create-job-and-send-proposal)**: "New bid from Riverside Dental: office rewire at 88 River Rd, rough-in $22,000 and fixtures $16,500. Create the Knowify job, save the proposal and send it to their office manager for signature." → `list_clients`, `create_client`, `list_jobs`, `create_job`, `save_proposal`, `send_proposal_for_signature`
- **Add a change order and invoice it**: "Add a $2,400 change order for the extra outlets on the Maple St job and invoice it." → `list_jobs`, `add_change_order`, `create_invoice`
- **[Progress invoices by percent complete, change orders included](https://cotlet.dev/integrations/knowify-api-mcp-server/bill-percent-complete-invoice)** (runs: monthly): "Bill Maple St at 60% on rough-in and 25% on fixtures, add the $2,400 kitchen outlet change order and bill it in full, then email the invoice to Dana once I approve it." → `list_jobs`, `get_job`, `list_invoices`, `add_change_order`, `create_invoice`, `send_invoice`
- **Log time on a job phase** (runs: daily): "Log 8 hours yesterday on the Maple St framing phase for me." → `list_jobs`, `get_job`, `log_time`
- **Record a client payment**: "Record the $12,500 check from Riverside Dental against their open invoice." → `list_invoices`, `record_payment`

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

Yes. Cotlet does not replace your automation platform: it gives it a Knowify 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 weekly report of job phases over budget, 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/knowify/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/knowify/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/knowify/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/knowify/{tool} with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 15 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 Knowify.

### list_jobs

Contract jobs with client, contract status, revenue, cost and profitability. Access: read. REST: `POST /api/v1/knowify/list_jobs`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | lead, bidding, out_for_signature, active, rejected or closed. Default: all open. |
| `search` | string | no | Job name, client name, address or tag. |
| `limit` | integer | no | 1 to 100. Default: 25. |

Returns contract jobs with client, status, revenue, cost and profit. Without a status filter it returns all open jobs, newest first. Search matches job name, client name, address or tag. Use job_id from each item in the other tools.

Example response:

```json
{
  "jobs": [
    {
      "job_id": "418203",
      "name": "Maple St Remodel",
      "client": "Dana Whitfield",
      "status": "active",
      "contract_style": "fixed_price",
      "revenue": 42400,
      "cost": 22500,
      "profit": 19900
    },
    {
      "job_id": "418410",
      "name": "Riverside Dental Office",
      "client": "Riverside Dental",
      "status": "lead",
      "contract_style": "fixed_price",
      "revenue": 0,
      "cost": 0,
      "profit": 0
    }
  ]
}
```

### get_job

One job: client, jobsite address, contract style, contract lines, change orders and phases. Access: read. REST: `POST /api/v1/knowify/get_job`.

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

Returns one job with its contract lines, change orders and phases. Contract line and change order IDs go into create_invoice; phase IDs go into log_time. Phases show whether labor is enabled.

Example response:

```json
{
  "job_id": "418203",
  "name": "Maple St Remodel",
  "client": {
    "client_id": "cl-2201",
    "name": "Dana Whitfield"
  },
  "jobsite_address": "214 Maple St, Springfield",
  "contract_style": "fixed_price",
  "contract_lines": [
    {
      "line_id": "line-1",
      "description": "Rough-in electrical",
      "price": 22000
    },
    {
      "line_id": "line-2",
      "description": "Fixtures and finish",
      "price": 18000
    }
  ],
  "change_orders": [
    {
      "change_order_id": "co-1",
      "description": "Extra outlets in the kitchen",
      "price": 2400,
      "status": "active"
    }
  ],
  "phases": [
    {
      "phase_id": "ph-1",
      "name": "Framing",
      "labor_enabled": true
    },
    {
      "phase_id": "ph-2",
      "name": "Rough-in",
      "labor_enabled": true
    }
  ]
}
```

### get_job_cost

Cost to date vs budget for the job and each phase, from Plan & Track. Access: read. REST: `POST /api/v1/knowify/get_job_cost`.

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

Returns cost to date against budget for the whole job and for each phase, the figures from Plan & Track. Phases over budget have a negative variance. The job totals are the sums of the phases.

Example response:

```json
{
  "job_id": "418203",
  "budget_total": 29000,
  "cost_total": 22500,
  "phases": [
    {
      "phase": "Framing",
      "budget": 14000,
      "cost": 15200,
      "variance": -1200
    },
    {
      "phase": "Rough-in",
      "budget": 9000,
      "cost": 6100,
      "variance": 2900
    },
    {
      "phase": "Finish",
      "budget": 6000,
      "cost": 1200,
      "variance": 4800
    }
  ]
}
```

### list_invoices

Invoices with job, client, amount, balance due and date. Access: read. REST: `POST /api/v1/knowify/list_invoices`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | no | Only invoices of this job. |
| `unpaid_only` | boolean | no | Skip invoices that are fully paid. |
| `since` | date | no | Only invoices dated on or after this date. |

Returns invoices newest first with job, client, amount, balance due and date. Set unpaid_only to see invoices with a balance due. Use invoice_id in send_invoice and record_payment.

Example response:

```json
{
  "invoices": [
    {
      "invoice_id": "90488",
      "job_id": "418120",
      "client": "Riverside Dental",
      "amount": 12500,
      "balance_due": 12500,
      "date": "2026-09-28"
    }
  ]
}
```

### list_clients

Clients with contact email, phone and address. Access: read. REST: `POST /api/v1/knowify/list_clients`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Client name. |

Returns clients with contact email, phone and address. Search matches the client name. Use client_id in create_job.

Example response:

```json
{
  "clients": [
    {
      "client_id": "cl-3310",
      "name": "Riverside Dental",
      "email": "office@riverside-dental.example",
      "phone": "555-0142",
      "address": "88 River Rd, Springfield"
    }
  ]
}
```

### list_time_entries

Time entries from Review Time: person, job, phase, hours, billable and approval state. Access: read. REST: `POST /api/v1/knowify/list_time_entries`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | no | Only entries on this job. |
| `from` | date | yes | First day. |
| `to` | date | yes | Last day. |
| `approved` | enum | no | all, approved or unapproved. Default: all. |

Returns the time entries you see in Review Time between two dates, with person, job, phase, hours, billable flag and approval state. Filter by job or by approved and unapproved to find entries waiting for review.

Example response:

```json
{
  "entries": [
    {
      "entry_id": "te-7701",
      "person": "Sam Ortiz",
      "job_id": "418203",
      "phase": "Framing",
      "date": "2026-10-09",
      "hours": 8,
      "billable": true,
      "approved": false
    }
  ]
}
```

### create_client

Add a client to your client list. Access: write. REST: `POST /api/v1/knowify/create_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Client name. |
| `email` | string | no | Contact email, used for proposals and invoices. |
| `phone` | string | no | Contact phone. |
| `address` | string | no | Billing address. |

Adds a client to your client list and returns its client_id for create_job. The email is used for proposals and invoices. It reaches no one, so it runs without asking first.

Example response:

```json
{
  "client_id": "cl-3311",
  "name": "Lakeview Dental",
  "email": "office@lakeview-dental.example",
  "status": "created"
}
```

### create_job

New contract job. It starts as a lead until a proposal is saved. Access: write. REST: `POST /api/v1/knowify/create_job`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Job name. |
| `client_id` | string | yes | Client ID from list_clients or create_client. |
| `contract_style` | enum | yes | fixed_price or cost_plus. |
| `jobsite_address` | string | no | Jobsite address. |
| `bid_due_date` | date | no | When the bid is due. |

Creates a contract job for a client. The job starts as a lead and moves to bidding when save_proposal runs. Contract style is fixed_price or cost_plus. It reaches no one, so it runs without asking first.

Example response:

```json
{
  "job_id": "418410",
  "name": "Riverside Dental Office",
  "client_id": "cl-3310",
  "contract_style": "fixed_price",
  "status": "lead"
}
```

### save_proposal

Save the draft proposal (bid) of a job. The job moves to bidding. Nothing is sent. Access: write. REST: `POST /api/v1/knowify/save_proposal`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `line_items` | object | yes | List of { description, price } contract lines. |

Saves the contract lines of the proposal as a draft and moves the job to bidding. Nothing is sent to the client; send_proposal_for_signature does that. It reaches no one, so it runs without asking first.

Example response:

```json
{
  "job_id": "418410",
  "status": "bidding",
  "proposal_total": 38500,
  "line_items": 2
}
```

### send_proposal_for_signature

Email the proposal to the client for e-signature. The job turns active when they sign. Access: write, asks the user first. REST: `POST /api/v1/knowify/send_proposal_for_signature`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `to_email` | string | no | Recipient. Default: the client's contact email. |

Emails the saved proposal to the client for e-signature. The recipient is the client's contact email unless you pass to_email. The job turns active when the client signs. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "job_id": "418410",
  "status": "out_for_signature",
  "sent_to": "office@riverside-dental.example"
}
```

### add_change_order

Add a change order to a fixed price job, as a draft or active so it can be invoiced. Access: write. REST: `POST /api/v1/knowify/add_change_order`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `description` | string | yes | What changed. |
| `price` | string | yes | Change order price as a decimal, e.g. 2400.00. |
| `make_active` | boolean | no | Make it active right away. Default: false. |

Adds a change order to a fixed price job. It is a draft unless make_active is true, and only an active change order can be invoiced. It reaches no client, so it runs without asking first.

Example response:

```json
{
  "change_order_id": "co-1",
  "job_id": "418203",
  "description": "Extra outlets in the kitchen",
  "price": 2400,
  "status": "active"
}
```

### create_invoice

Invoice an active job by percent of progress or dollar amount per line, as a draft or finalized. Access: write, asks the user first. REST: `POST /api/v1/knowify/create_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `method` | enum | yes | percent or amount. |
| `lines` | object | yes | Map of contract line or change order ID to percent or amount to bill. |
| `finalize` | boolean | no | Verify and finalize instead of saving a draft. Default: false. |

Invoices an active job by percent of progress or by dollar amount per contract line or change order. It saves a draft unless finalize is true. The invoice amount is the sum of the billed lines. It does not email anyone; send_invoice does. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": "90517",
  "job_id": "418203",
  "status": "draft",
  "amount": 18400,
  "balance_due": 18400,
  "date": "2026-10-10"
}
```

### send_invoice

Email a finalized invoice to the client. Access: write, asks the user first. REST: `POST /api/v1/knowify/send_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `invoice_id` | string | yes | Invoice ID from list_invoices or create_invoice. |
| `to_email` | string | no | Recipient. Default: the client's contact email. |

Emails a finalized invoice to the client. The recipient is the client's contact email unless you pass to_email. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": "90517",
  "status": "sent",
  "sent_to": "dana.whitfield@example.com"
}
```

### record_payment

Record a full or partial client payment on an invoice. Access: write, asks the user first. REST: `POST /api/v1/knowify/record_payment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `invoice_id` | string | yes | Invoice ID from list_invoices. |
| `amount` | string | yes | Amount received as a decimal, e.g. 12500.00. |
| `date` | date | yes | Payment date. |
| `memo` | string | no | Check number or note. |

Records a full or partial client payment on an invoice and returns the new balance due. The memo holds a check number or note. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": "90488",
  "amount": 12500,
  "date": "2026-10-09",
  "memo": "Check 4471",
  "balance_due": 0
}
```

### log_time

Enter hours on a job phase in the Time Tracker and submit them for review. Access: write. REST: `POST /api/v1/knowify/log_time`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `job_id` | string | yes | Job ID from list_jobs. |
| `phase_id` | string | yes | Phase ID from get_job. The phase must have labor enabled. |
| `date` | date | yes | Day worked. |
| `hours` | string | yes | Hours worked as a decimal, e.g. 7.5. |
| `description` | string | no | What was done. |

Enters hours on a job phase in the Time Tracker and submits them for review, where they appear in Review Time. The phase must have labor enabled. It reaches no client, so it runs without asking first.

Example response:

```json
{
  "entry_id": "te-7702",
  "job_id": "418203",
  "phase": "Framing",
  "date": "2026-10-09",
  "hours": 8,
  "status": "submitted"
}
```

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

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

### Connect Knowify to your agent.

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

2. **Sign in to Knowify once** Open the connect page from the console and sign in to Knowify 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 Knowify 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.

```
Every Monday at 7, list the active Knowify jobs with a phase over budget or above 90% of its budget, biggest overrun first.
```

### Call Knowify 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/knowify/{tool}. Send its parameters as JSON, exactly as listed in the endpoints above.

```
curl https://cotlet.dev/api/v1/knowify/create_invoice \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"job_id":"418203","method":"percent","lines":{"line-1":40,"line-2":40,"co-1":100},"finalize":false}'
```

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

```
{
  "invoice_id": "90517",
  "job_id": "418203",
  "status": "draft",
  "amount": 18400,
  "balance_due": 18400,
  "date": "2026-10-10"
}
```

## Why use Cotlet for Knowify?

**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 Knowify 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 Knowify changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is there a Knowify MCP server on GitHub?

No open-source Knowify MCP servers turned up. Knowify's own AI Connector answers questions about your data for admins, and its Zapier app creates jobs, clients, bills and tasks. Cotlet adds the writes neither covers: proposals, change orders, invoices, payments and time.

|  | Knowify AI Connector | Cotlet |
|---|---|---|
| Setup | Add the connector URL in Claude or Grok, or the ChatGPT plugin, then sign in | Request access, sign in to Knowify once in your browser, add one MCP server or API key |
| Who can connect | Users with admin permissions only | Your own account, with the permissions it already has |
| What it does | Answers questions: WIP, billing, labor, collections | Reads jobs and costs, and does the work: proposals, change orders, invoices, payments, time |
| When Knowify changes | Knowify maintains it | Our team tests it daily and fixes it for you; failed calls are free |
| Your Knowify session | OAuth sign-in with Knowify | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| Where it runs | Claude, ChatGPT, Grok and other MCP clients | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Included with Knowify | 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 Knowify 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 Knowify API cost?

Free 7-day trial with 5,000 credits, no card needed. After that, the Knowify 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 Knowify 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 Knowify 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 Knowify tool you allowed. When it expires, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security)
- **Revoking access:** Disconnect Knowify 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.
- **Knowify's terms:** You use your own Knowify account and stay responsible for following Knowify's terms. Cotlet is independent and not affiliated with Knowify. [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 Knowify. Cotlet reviews each request and emails you your API key.

**Do I need to be technical?**

No. You sign in to Knowify 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 Knowify session would leave my computer.**

Cotlet keeps your Knowify 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.

**Can my agent send an invoice without my OK?**

Yes, once you switch confirmation off for send_invoice. By default each email to a client and each payment record waits for your OK. Knowify's own AI Connector is read-only for now (checked 11 Oct 2026).

**Do I need admin permissions in Knowify?**

Cotlet works in your own Knowify account with the permissions it already has. Knowify's AI Connector needs admin permissions to connect.

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

No. Every call to send_proposal_for_signature, create_invoice, send_invoice or record_payment waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. create_client, create_job, save_proposal, add_change_order, log_time runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Knowify 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/knowify/{tool} from the HTTP Request node.