# DoorLoop API and MCP server

> DoorLoop has an open REST API, but it is not self-serve (checked 11 Oct 2026). The pricing page lists API access on the Premium plan only, DoorLoop says it is "still selective about who gets access", and you apply and talk by phone before you get the documentation. There is no official DoorLoop MCP server.

Property management software for landlords and property managers: properties and units, tenants, leases, rent collection, maintenance tasks, communications and accounting.

## What is the DoorLoop API?

Cotlet's DoorLoop API exposes 14 endpoints for your own DoorLoop account: list properties, list units, list tenants, list leases, get lease transactions, list tasks, list communications, create tenant, create task, create lease, post lease charge, record lease payment, issue lease credit and send announcement. The list_properties endpoint returns your properties with address, type and unit count. Each endpoint takes simple JSON inputs like cursor, property_id or lease_id and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Real estate](https://cotlet.dev/integrations/category/real-estate)
- **Endpoints:** 14 (7 read, 7 write)
- **Updated:** 2026-10-11

DoorLoop has an open REST API, but it is not self-serve (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for DoorLoop with 14 endpoints (7 read, 7 write): your AI agent signs in as you and does the work.

## Does DoorLoop have an official API?

DoorLoop has an open REST API, but it is not self-serve (checked 11 Oct 2026). The pricing page lists API access on the Premium plan only, DoorLoop says it is "still selective about who gets access", and you apply and talk by phone before you get the documentation. There is no official DoorLoop MCP server.

| Task | DoorLoop official | Cotlet |
|---|---|---|
| List tenants, units and leases | Partly: Premium plan and DoorLoop approval; Zapier has Find Lease, Find Tenant or Prospect and Find Unit | Yes |
| Create a lease with term, deposit and charges | Partly: The API reference documents Create a Lease; Premium and approval | Yes |
| Post a one-time charge, such as a late fee | Partly: Zapier action Create Lease Charge; Premium | Yes |
| Issue a lease credit | Partly: Zapier action Create Lease Credit; Premium | Yes |
| Create a task or work order | Partly: Zapier action Create a Task/Work Order; Premium | Yes |
| Record a rent payment | Partly: The API reference documents Create a Lease Payment; Premium and approval. Zapier has a New Lease Payment trigger but no action to record one | Yes |
| Send an announcement by email, text, voice or tenant portal | No: Only in the DoorLoop app, on Pro or Premium | Yes |
| Read the Communications Log | Partly: The API reference documents List all Communication Logs; Premium and approval | Yes |

Sources: [DoorLoop pricing (API access, Zapier, plans)](https://www.doorloop.com/pricing), [DoorLoop partner page (apply for API access)](https://www.doorloop.com/partner), [DoorLoop API reference: authentication](https://api.doorloop.com/reference/authentication), [DoorLoop API reference: create a lease payment](https://api.doorloop.com/reference/post-lease-payment), [DoorLoop Help: send an announcement to your tenants](https://support.doorloop.com/en/articles/6075940-send-an-announcement-to-your-tenants), [DoorLoop Help: receive a payment on a lease](https://support.doorloop.com/en/articles/6162667-receive-a-payment-on-a-lease), [DoorLoop Help: set up automatic late fees](https://support.doorloop.com/en/articles/6191191-set-up-automatic-late-fees)

## For AI agents

```text
DoorLoop has an open REST API, but it is not self-serve (checked 11 Oct 2026). The pricing page lists API access on the Premium plan only, DoorLoop says it is "still selective about who gets access", and you apply and talk by phone before you get the documentation. There is no official DoorLoop MCP server.
Cotlet provides a hosted MCP server and REST API for DoorLoop: 14 tools (7 read, 7 write).
Access       Request access at https://cotlet.dev/app/signup?app=doorloop; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/doorloop
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_properties, list_units, list_tenants, list_leases, get_lease_transactions, list_tasks, list_communications, create_tenant, create_task, create_lease, post_lease_charge, record_lease_payment, issue_lease_credit, send_announcement
Confirm      create_lease, post_lease_charge, record_lease_payment, issue_lease_credit, send_announcement (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/doorloop-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=doorloop (DoorLoop is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to DoorLoop 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 DoorLoop server that someone else maintains, including non-developers. Developers who prefer to run and fix code on their own computer can use an open-source DoorLoop MCP server instead.

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 DoorLoop 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 DoorLoop's terms; Cotlet is not affiliated with DoorLoop.
```

## What can an AI agent do in DoorLoop?

Cotlet is best for landlords and small property managers who want their AI agent to post charges, record payments, set up leases and message tenants in DoorLoop without running or fixing a server.

- **[Record check and cash rent payments](https://cotlet.dev/integrations/doorloop-api-mcp-server/record-rent-payments)** (runs: daily): "Record today's rent checks in DoorLoop: Unit 2B Marcus Hale $1,450 check 1042, Unit 3A Priya Shah $1,500 cash, Unit 6 Leo Brandt $1,640 by Zelle. Skip anything already entered and tell me what is still owed." → `list_leases`, `get_lease_transactions`, `record_lease_payment`
- **[Send announcements to tenants of a property](https://cotlet.dev/integrations/doorloop-api-mcp-server/send-tenant-announcements)** (runs: weekly): "Tell all tenants at Maple Court by email and text that the water is off Thursday from 9 to 12, show me the text first, and later tell me whose text failed." → `list_properties`, `send_announcement`, `list_communications`
- **[Set up a new lease](https://cotlet.dev/integrations/doorloop-api-mcp-server/create-lease)**: "Set up a 12-month lease for Dana Reed (dana@example.com) in Unit 4 at Maple Court, $1,600 a month due on the 1st, starting Nov 1, with a $1,600 deposit. Check the unit is free first." → `list_units`, `list_leases`, `list_tenants`, `create_tenant`, `create_lease`
- **Charge late fees on unpaid rent** (runs: monthly): "Find leases that still owe October rent and post a $50 late fee on each one." → `list_leases`, `get_lease_transactions`, `post_lease_charge`
- **Find leases ending soon and vacant units** (runs: weekly): "Which leases end in the next 60 days, and which units are vacant?" → `list_leases`, `list_units`

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

Yes. Cotlet does not replace your automation platform: it gives it a DoorLoop 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 record check and cash rent payments, 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/doorloop/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/doorloop/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/doorloop/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/doorloop/{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 DoorLoop.

### list_properties

Your properties with address, type and unit count. Access: read. REST: `POST /api/v1/doorloop/list_properties`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Match on property name or address. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns the properties in your DoorLoop account, with address and number of units. Search matches the property name or address. Use the property_id of each item in the other tools.

Example response:

```json
{
  "properties": [
    {
      "property_id": "pr_3a91c7",
      "name": "Maple Court",
      "address": "120 Maple St, Springfield",
      "type": "Multi-family",
      "units": 12
    }
  ],
  "next_cursor": null
}
```

### list_units

Units with property, rent and whether each is occupied or vacant. Access: read. REST: `POST /api/v1/doorloop/list_units`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property_id` | string | no | Only this property. Property ID from list_properties. |
| `status` | enum | no | all, occupied or vacant. Default: all. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns units with the property they belong to and their occupancy. Filter by property or by occupied or vacant. Use unit_id from here in create_lease.

Example response:

```json
{
  "units": [
    {
      "unit_id": "un_5b20d4",
      "property": "Maple Court",
      "name": "Unit 4",
      "status": "vacant",
      "market_rent": "1600.00"
    }
  ],
  "next_cursor": null
}
```

### list_tenants

Tenants with email, phone, unit and current lease. Access: read. REST: `POST /api/v1/doorloop/list_tenants`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Match on name, email or phone. |
| `property_id` | string | no | Only this property. Property ID from list_properties. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns tenants with contact details and the lease they are on. Search matches name, email or phone. Use tenant_id from here in create_lease.

Example response:

```json
{
  "tenants": [
    {
      "tenant_id": "tn_91c0e7",
      "name": "Dana Reed",
      "email": "dana@example.com",
      "phone": "+15555550123",
      "unit": "Unit 4",
      "lease_id": null
    }
  ],
  "next_cursor": null
}
```

### list_leases

Leases with unit, tenants, rent, start and end dates and balance due. Access: read. REST: `POST /api/v1/doorloop/list_leases`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Match on unit or tenant name. |
| `status` | enum | no | active or ended. Default: active. |
| `ends_before` | date | no | Only leases ending on or before this date. |
| `property_id` | string | no | Only this property. Property ID from list_properties. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns leases with the unit, the tenants on them, monthly rent, dates and the balance due. Filter by status, by end date or by property. Use lease_id from here in the other lease tools. Search matches unit or tenant name.

Example response:

```json
{
  "leases": [
    {
      "lease_id": "ls_64f1a9c2",
      "unit": "Unit 2B",
      "property": "Maple Court",
      "tenants": [
        "Marcus Hale"
      ],
      "rent": "1450.00",
      "start_date": "2026-01-01",
      "end_date": "2026-12-31",
      "balance_due": "1450.00"
    }
  ],
  "next_cursor": null
}
```

### get_lease_transactions

Charges, payments and credits on a lease, oldest first, with the running balance. Access: read. REST: `POST /api/v1/doorloop/get_lease_transactions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lease_id` | string | yes | Lease ID from list_leases. |
| `from` | date | no | Start date. Default: lease start. |
| `to` | date | no | End date. Default: today. |

Returns the ledger of one lease, oldest first: charges, payments and credits, each with a running balance. Use it to see whether a rent charge is still open before you add a fee or record a payment.

Example response:

```json
{
  "lease_id": "ls_64f1a9c2",
  "transactions": [
    {
      "type": "charge",
      "date": "2026-10-01",
      "description": "Rent October 2026",
      "amount": "1450.00",
      "balance": "1450.00"
    }
  ],
  "balance_due": "1450.00"
}
```

### list_tasks

Tasks and work orders with status, due date, property and assignee. Access: read. REST: `POST /api/v1/doorloop/list_tasks`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | string | no | Only tasks with this status, as DoorLoop shows it. |
| `property_id` | string | no | Only this property. Property ID from list_properties. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns tasks and work orders, filtered by status or property. Each item has its subject, the property or unit it concerns, the due date and who it is assigned to.

Example response:

```json
{
  "tasks": [
    {
      "task_id": "tk_20c8",
      "subject": "Fix hallway light",
      "property": "Maple Court",
      "unit": null,
      "status": "open",
      "due_date": "2026-10-15",
      "assignee": "Sam Ortiz"
    }
  ],
  "next_cursor": null
}
```

### list_communications

The Communications Log: announcements and messages sent, with channel and delivery status. Access: read. REST: `POST /api/v1/doorloop/list_communications`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `since` | datetime | no | Only entries sent after this time. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns entries from the Communications Log, newest first, with the channel, subject and delivery status. Use it after send_announcement to see who the announcement reached.

Example response:

```json
{
  "communications": [
    {
      "communication_id": "cm_77f0",
      "subject": "Water shutoff Thursday",
      "channel": "email",
      "sent_at": "2026-10-11T09:02:00Z",
      "delivery": "delivered",
      "recipients": 12
    }
  ],
  "next_cursor": null
}
```

### create_tenant

Add a tenant contact, ready to put on a lease. Sends nothing. Access: write. REST: `POST /api/v1/doorloop/create_tenant`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `first_name` | string | yes | First name. |
| `last_name` | string | yes | Last name. |
| `email` | string | no | Email address. |
| `phone` | string | no | Phone number, E.164. |

Adds one tenant contact. It sends nothing to the tenant and attaches no charge. It runs without asking first, because it reaches no one and the contact can be deleted in DoorLoop.

Example response:

```json
{
  "tenant_id": "tn_91c0e7",
  "name": "Dana Reed",
  "email": "dana@example.com",
  "status": "created"
}
```

### create_task

New task or work order for a property or unit. Access: write. REST: `POST /api/v1/doorloop/create_task`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `subject` | string | yes | Short title. |
| `description` | string | no | Details for whoever does the work. |
| `property_id` | string | no | Only this property. Property ID from list_properties. |
| `unit_id` | string | no | Unit it concerns. |
| `due_date` | date | no | Due date. |

Creates a task or work order with a subject, optional property or unit and a due date. It does not message anyone by itself. It runs without asking first, because it reaches no tenant and the task can be removed in DoorLoop.

Example response:

```json
{
  "task_id": "tk_20c9",
  "subject": "Replace smoke detector, Unit 2B",
  "property": "Maple Court",
  "due_date": "2026-10-18",
  "status": "created"
}
```

### create_lease

New lease on a unit with tenants, term, monthly rent and security deposit. Access: write, asks the user first. REST: `POST /api/v1/doorloop/create_lease`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `unit_id` | string | yes | Unit ID from list_units. |
| `tenant_ids` | string[] | yes | Tenant IDs from list_tenants or create_tenant. |
| `start_date` | date | yes | First day of the lease. |
| `end_date` | date | no | Last day. Leave empty for month-to-month. |
| `rent` | object | yes | amount and due_day of the recurring rent charge. |
| `security_deposit` | object | no | amount and due_date. |

Creates a lease on one unit in a single step: tenants, term, recurring rent with its due day and an optional security deposit. Leave end_date empty for a month-to-month lease. The lease creates charges on the ledger. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "lease_id": "ls_9e13b5",
  "unit": "Unit 4",
  "tenants": [
    "Dana Reed"
  ],
  "start_date": "2026-11-01",
  "end_date": "2027-10-31",
  "rent": {
    "amount": "1600.00",
    "due_day": 1
  },
  "security_deposit": {
    "amount": "1600.00",
    "due_date": "2026-11-01"
  },
  "status": "created"
}
```

### post_lease_charge

One-time charge on a lease, such as a late fee. It shows on the tenant's balance. Access: write, asks the user first. REST: `POST /api/v1/doorloop/post_lease_charge`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lease_id` | string | yes | Lease ID from list_leases. |
| `amount` | string | yes | Decimal amount, e.g. "50.00". |
| `date` | date | yes | Charge date. |
| `account` | string | yes | Income account, as named in your DoorLoop chart of accounts. |
| `memo` | string | no | Shown on the ledger. |

Adds one charge to a lease ledger, for example a late fee or a utility bill. It raises the balance due. It does not change your late fee policy. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "charge_id": "ch_41b7",
  "lease_id": "ls_64f1a9c2",
  "amount": "50.00",
  "date": "2026-10-11",
  "account": "Late Fees",
  "balance_due": "1500.00",
  "status": "posted"
}
```

### record_lease_payment

Record a payment received outside online payments and apply it to open charges. Access: write, asks the user first. REST: `POST /api/v1/doorloop/record_lease_payment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lease_id` | string | yes | Lease ID from list_leases. |
| `amount` | string | yes | Decimal amount received. |
| `date` | date | yes | Date received. |
| `method` | string | yes | Payment method as DoorLoop lists it, e.g. check or cash. |
| `reference` | string | no | Check number or other reference. |

Records a payment on a lease, the same as Receive Payment in DoorLoop, and applies it to open charges. The response lists the charges it was applied to and the balance after. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "payment_id": "pm_8d2e71b0",
  "lease_id": "ls_64f1a9c2",
  "amount": "1450.00",
  "method": "check",
  "reference": "1042",
  "applied_to": [
    {
      "charge": "Rent October 2026",
      "amount": "1450.00"
    }
  ],
  "balance_due": "0.00"
}
```

### issue_lease_credit

Credit a lease, such as a rent concession, lowering the tenant's balance. Access: write, asks the user first. REST: `POST /api/v1/doorloop/issue_lease_credit`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lease_id` | string | yes | Lease ID from list_leases. |
| `amount` | string | yes | Decimal amount. |
| `date` | date | yes | Credit date. |
| `memo` | string | no | Reason, shown on the ledger. |

Adds a credit to a lease ledger, which lowers the balance due. Use the memo to record the reason. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "credit_id": "cr_19a4",
  "lease_id": "ls_64f1a9c2",
  "amount": "100.00",
  "date": "2026-10-11",
  "balance_due": "1350.00",
  "status": "posted"
}
```

### send_announcement

Announcement to tenants by email, text or tenant portal. Texts use announcement credits. Access: write, asks the user first. REST: `POST /api/v1/doorloop/send_announcement`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `subject` | string | yes | Announcement title. |
| `body` | string | yes | Message text. |
| `property_ids` | string[] | no | Only tenants in these properties. Default: all. |
| `channels` | string[] | yes | Any of email, text, portal. |

Sends an announcement to tenants of the full portfolio or of chosen properties. Email and portal posts are free. Text messages use announcement credits (1 per 160 characters) and are capped at 800 characters. Announcements need DoorLoop's Pro or Premium plan. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "communication_id": "cm_77f0",
  "subject": "Water shutoff Thursday",
  "channels": [
    "email",
    "text"
  ],
  "recipients": 12,
  "status": "sent"
}
```

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

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

### Connect DoorLoop to your agent.

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

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

```
Record today's rent checks in DoorLoop: Unit 2B Marcus Hale $1,450 check 1042, Unit 3A Priya Shah $1,500 cash, Unit 6 Leo Brandt $1,640 by Zelle. Skip anything already entered and tell me what is still owed.
```

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

```
curl https://cotlet.dev/api/v1/doorloop/record_lease_payment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"lease_id":"ls_64f1a9c2","amount":"1450.00","date":"2026-10-11","method":"check","reference":"1042"}'
```

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

```
{
  "payment_id": "pm_8d2e71b0",
  "lease_id": "ls_64f1a9c2",
  "amount": "1450.00",
  "method": "check",
  "reference": "1042",
  "applied_to": [
    {
      "charge": "Rent October 2026",
      "amount": "1450.00"
    }
  ],
  "balance_due": "0.00"
}
```

## Why use Cotlet for DoorLoop?

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

## Is there a DoorLoop MCP server on GitHub?

Yes. Community DoorLoop CLIs and MCP servers exist on GitHub, usually maintained by one person. They need a DoorLoop API token, so they only work if your account has API access. You install and fix them yourself; Cotlet hosts and maintains the same for you, and works in your signed-in session.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Get API access from DoorLoop, create a token, install the tool, add it to each MCP client | Request access, sign in to DoorLoop once, add one MCP server or API key |
| When DoorLoop changes | It breaks until you or the maintainer fix it | Our team tests it daily and fixes it for you; failed calls are free |
| Your DoorLoop access | An API token in a file or environment variable on your computer | Your session, encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When access expires | Tools fail until you replace the token | We keep the session alive; if DoorLoop logs you out, your agent gets a link to sign in again |
| Upkeep | You update, monitor and debug it yourself | Nothing to host or update |
| Where it runs | Your computer, while it is on | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free, paid for with your time | 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 DoorLoop 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 DoorLoop API cost?

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

**Do I need to be technical?**

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

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

**Do I need DoorLoop's Premium plan or API access?**

No. Cotlet works in your own DoorLoop account and does not use the API or Zapier, which DoorLoop lists on Premium. Announcements need Pro or Premium, because DoorLoop does not offer them on Starter.

**Does a text announcement cost extra?**

Yes, in DoorLoop. Text messages use announcement credits, 1 credit per 160 characters, while email and tenant portal posts are free. Cotlet does not add to that; it bills only its own credits per call.

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

No. Every call to create_lease, post_lease_charge, record_lease_payment, issue_lease_credit or send_announcement 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_tenant, create_task runs without asking, because it sends nothing to anyone and one call undoes it.

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