# Rently API and MCP server

> Rently has a public API for smart home devices and lock codes, but no on-demand API for leads, showings or listing status (checked 11 Oct 2026). Tour webhooks, lead data exports and partner credentials are set up by Rently staff, and the property feed is pulled once an hour.

Self-guided rental tours for property managers: lockboxes and smart locks let renters tour homes and apartments on their own, while the manager tracks leads and showings in Rently Tour Manager.

## What is the Rently API?

Cotlet's Rently API exposes 14 endpoints for your own Rently account: list properties, get property activity, list leads, get lead, list Safe Mode requests, get Data Dashboard, export report, assign lead, set self-touring, grant Safe Mode access, dismiss Safe Mode request, create visitor access code, send self-tour invite and ban prospect. The list_properties endpoint returns properties or units in your account with address, rent, showing status and assigned lockbox. Each endpoint takes simple JSON inputs like property_id, from or to 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

Rently has a public API for smart home devices and lock codes, but no on-demand API for leads, showings or listing status (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Rently with 14 endpoints (7 read, 7 write): your AI agent signs in as you and does the work.

## Does Rently have an official API?

Rently has a public API for smart home devices and lock codes, but no on-demand API for leads, showings or listing status (checked 11 Oct 2026). Tour webhooks, lead data exports and partner credentials are set up by Rently staff, and the property feed is pulled once an hour.

| Task | Rently official | Cotlet |
|---|---|---|
| List leads and see who toured | Partly: Lead reports and tour webhooks, set up by Rently staff | Yes |
| Assign a lead to an agent | No | Yes |
| Approve or dismiss Safe Mode requests | No | Yes |
| Turn self-touring on or off for a listing | Partly: Hourly JSON feed from your system, not on demand | Yes |
| Create a visitor access code | Partly: Touring API with credentials issued by Rently | Yes |
| Send a self-tour invite to a prospect | No | Yes |
| Read showings, inquiries and waitlist per property | Partly: Webhook events only, no read endpoint | Yes |
| Data Dashboard numbers | No | Yes |

Sources: [Rently API reference](https://apidocs.rently.com/llms.txt), [Rently: requesting a webhook integration](https://rentlyone.my.site.com/PropertyManagerHelpCenter/s/article/How-to-Request-Webhook-Integration-with-Rently-Activities-Notification-Overview-SF), [Rently: property data sync (hourly feed)](https://apidocs.rently.com/reference/stage-1-property-data-sync-into-rently), [Rently: visitor access code API](https://apidocs.rently.com/reference/rently-visitor-access-codes-v1), [Rently: Lead Activities report fields](https://apidocs.rently.com/reference/lead-activities-report)

## For AI agents

```text
Rently has a public API for smart home devices and lock codes, but no on-demand API for leads, showings or listing status (checked 11 Oct 2026). Tour webhooks, lead data exports and partner credentials are set up by Rently staff, and the property feed is pulled once an hour.
Cotlet provides a hosted MCP server and REST API for Rently: 14 tools (7 read, 7 write).
Access       Request access at https://cotlet.dev/app/signup?app=rently; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/rently
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_properties, get_property_activity, list_leads, get_lead, list_safe_mode_requests, get_dashboard, export_report, assign_lead, set_self_touring, grant_safe_mode_access, dismiss_safe_mode_request, create_visitor_access_code, send_self_tour_invite, ban_prospect
Confirm      grant_safe_mode_access, dismiss_safe_mode_request, create_visitor_access_code, send_self_tour_invite, ban_prospect (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/rently-api-mcp-server.md

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

## What can an AI agent do in Rently?

Cotlet is best for property managers and leasing teams who want their AI agent to assign leads, approve Safe Mode visits and track showings in Rently without running or fixing a server.

- **[Approve Safe Mode viewing requests](https://cotlet.dev/integrations/rently-api-mcp-server/approve-safe-mode-requests)** (runs: daily): "Go through the pending Safe Mode requests in Rently. Approve prospects with a phone and email who are not banned and have no complaint in their comments, dismiss anyone who asked to pay a deposit before touring, and leave the rest for me." → `list_safe_mode_requests`, `get_lead`, `grant_safe_mode_access`, `dismiss_safe_mode_request`, `ban_prospect`
- **[Assign new leads to agents](https://cotlet.dev/integrations/rently-api-mcp-server/assign-leads-to-agents)** (runs: daily): "Find Rently leads from the last month with no agent. Give leads for the Charlotte homes to Anna, the Rock Hill homes to Mark, and split anything else between them evenly." → `list_leads`, `get_lead`, `assign_lead`
- **[Turn off self-touring when a home is leased](https://cotlet.dev/integrations/rently-api-mcp-server/turn-off-self-touring-when-leased)**: "412 Oak St and 19 Birch Ct are leased. Turn off self-touring at both, dismiss any Safe Mode requests still waiting there, and tell me if either one comes from our PMS feed." → `list_properties`, `list_safe_mode_requests`, `set_self_touring`, `dismiss_safe_mode_request`
- **[Weekly report of homes with no showings](https://cotlet.dev/integrations/rently-api-mcp-server/find-properties-with-no-showings)** (runs: weekly): "Every Monday, list my on-market Rently homes with no showings in the last 14 days, with how many inquiries each had and how long it has been on market, plus last week's total leads and self-showings." → `get_dashboard`, `list_properties`, `get_property_activity`

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

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

### list_properties

Properties or units in your account with address, rent, showing status and assigned lockbox. Access: read. REST: `POST /api/v1/rently/list_properties`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `market` | enum | no | on_market, off_market or all. Default: all. |
| `search` | string | no | Part of an address or a CRM tag. |
| `limit` | integer | no | 1 to 100. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the properties and units in your Rently account, with address, rent, showing status and the assigned lockbox. Filter by market to see only on-market or off-market homes, or search by part of an address or a CRM tag. Pages hold up to 100 properties; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "properties": [
    {
      "property_id": "1658203",
      "address": "88 Elm Ave, Charlotte, NC",
      "rent": 1850,
      "market": "on_market",
      "showing_status": "self-touring on",
      "lockbox": "LB-20418"
    },
    {
      "property_id": "1658301",
      "address": "412 Oak St, Charlotte, NC",
      "rent": 1495,
      "market": "on_market",
      "showing_status": "self-touring on",
      "lockbox": "LB-20533"
    }
  ],
  "next_cursor": null
}
```

### get_property_activity

Activity Log of a property: status dates, lead traffic sources, showings with type and feedback, inquiries, waitlist and vendor entries. Access: read. REST: `POST /api/v1/rently/get_property_activity`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property_id` | string | yes | Property or unit ID from list_properties. |
| `from` | date | no | Start of the date range for leasing activities. |
| `to` | date | no | End of the date range. Default: today. |

Returns the Activity Log of one property for a date range. It holds status dates, lead traffic sources, showings with their type and feedback, inquiries, waitlist entries and vendor entries. Without from and to, it covers up to today.

Example response:

```json
{
  "property_id": "1658203",
  "address": "88 Elm Ave, Charlotte, NC",
  "from": "2026-09-27",
  "to": "2026-10-11",
  "showings": [
    {
      "type": "self_registered_viewing",
      "at": "2026-10-04T15:20:00-04:00",
      "feedback": "Liked the kitchen"
    }
  ],
  "inquiries": 3,
  "waitlist": 1
}
```

### list_leads

Leads from the Leads page with status, source, assigned agent and creation date. Access: read. REST: `POST /api/v1/rently/list_leads`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `view` | enum | no | all, iqual_plus or safe_mode. Default: all. |
| `period` | enum | no | last_1_month, last_3_months, last_6_months or all. Default: last_1_month. |
| `agent` | string | no | Only leads assigned to this agent email; "none" for unassigned. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the leads on the Leads page with status, source, assigned agent and the date the lead was created. Set view to iqual_plus or safe_mode to see one group, and agent to "none" to see only unassigned leads. The default period is the last month. Pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "leads": [
    {
      "lead_id": "4417203",
      "name": "Maya Brooks",
      "status": "New",
      "source": "Zillow",
      "agent": null,
      "created_at": "2026-10-08T10:12:00-04:00"
    },
    {
      "lead_id": "4417390",
      "name": "Dan Rivera",
      "status": "Toured",
      "source": "Website",
      "agent": "mark@example.com",
      "created_at": "2026-10-09T16:40:00-04:00"
    }
  ],
  "next_cursor": null
}
```

### get_lead

One lead: name, phone, email, status, assigned agent, comments, source and properties toured. Access: read. REST: `POST /api/v1/rently/get_lead`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lead_id` | string | yes | Lead ID from list_leads. |

Returns one lead from its detail page: name, phone, email, status, assigned agent, comments, source and the properties the lead toured. Use it to check a prospect before you approve a Safe Mode visit.

Example response:

```json
{
  "lead_id": "4417203",
  "name": "Maya Brooks",
  "phone": "+15555550177",
  "email": "maya@example.com",
  "status": "New",
  "agent": null,
  "source": "Zillow",
  "comments": "Asked about pet policy.",
  "properties_toured": []
}
```

### list_safe_mode_requests

Pending SafeMode Requests: prospects who scheduled a viewing that waits for your approval. Access: read. REST: `POST /api/v1/rently/list_safe_mode_requests`.

No parameters.

Lists the pending Safe Mode requests: prospects who scheduled a viewing that waits for your approval. Each item has the lead and the property. Pass request_id to grant_safe_mode_access or dismiss_safe_mode_request, and lead_id to get_lead.

Example response:

```json
{
  "requests": [
    {
      "request_id": "sm_90412",
      "lead_id": "4417203",
      "name": "Maya Brooks",
      "property_id": "1658203",
      "address": "88 Elm Ave, Charlotte, NC",
      "scheduled_for": "2026-10-12T17:00:00-04:00"
    }
  ]
}
```

### get_dashboard

Total self-showings, total leads, devices, on-market and off-market properties, and leads by source. Access: read. REST: `POST /api/v1/rently/get_dashboard`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `period` | enum | no | last_week, last_month, last_quarter or custom. Default: last_week. |
| `from` | date | no | Start date, for custom only. |
| `to` | date | no | End date, for custom only. |

Returns the figures from the Data Dashboard for one period: total self-showings, total leads, devices, on-market and off-market properties, and leads by source. The default period is last week; use custom with from and to for any other range.

Example response:

```json
{
  "period": "last_week",
  "self_showings": 38,
  "leads": 64,
  "devices": 21,
  "on_market": 14,
  "off_market": 7,
  "leads_by_source": {
    "Zillow": 31,
    "Website": 18,
    "Apartments_com": 15
  }
}
```

### export_report

Data Export as a CSV download link. Admins and Super Admins only. Access: read. REST: `POST /api/v1/rently/export_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `data_category` | enum | yes | lockboxes, lead_activities or survey_feedback. |
| `from` | date | no | Start date. Not used for lockboxes. |
| `to` | date | no | End date. Not used for lockboxes. |

Creates a Data Export for one category and returns a CSV download link. Categories are lockboxes, lead_activities and survey_feedback. Only Admins and Super Admins can export. The date range does not apply to lockboxes.

Example response:

```json
{
  "data_category": "lead_activities",
  "from": "2026-09-01",
  "to": "2026-09-30",
  "rows": 212,
  "download_url": "https://files.example.com/exports/lead_activities_2026-09.csv"
}
```

### assign_lead

Assign a lead to one of your agents. Access: write. REST: `POST /api/v1/rently/assign_lead`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lead_id` | string | yes | Lead ID from list_leads. |
| `agent_email` | string | yes | Email of the agent in your account. |

Assigns one lead to an agent in your account, identified by email. The agent must already exist in Rently. It reaches no renter and one more call assigns the lead to someone else, so it runs without asking first.

Example response:

```json
{
  "lead_id": "4417203",
  "agent": "anna@example.com",
  "status": "assigned"
}
```

### set_self_touring

Turn self-touring on or off for a property or unit, e.g. once it is leased. Access: write. REST: `POST /api/v1/rently/set_self_touring`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property_id` | string | yes | Property or unit ID from list_properties. |
| `enabled` | boolean | yes | true to allow self-guided tours, false to stop them. |

Turns self-guided tours on or off for one property or unit. Set enabled to false when a home is leased and true to open it again. It changes no data of renters and one call undoes it, so it runs without asking first.

Example response:

```json
{
  "property_id": "1658301",
  "address": "412 Oak St, Charlotte, NC",
  "self_touring": false,
  "status": "updated"
}
```

### grant_safe_mode_access

Approve a Safe Mode viewing; the prospect gets access to tour the property. Access: write, asks the user first. REST: `POST /api/v1/rently/grant_safe_mode_access`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `request_id` | string | yes | Request ID from list_safe_mode_requests. |

Approves one pending Safe Mode request, so the prospect gets access to tour the property at the scheduled time. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "request_id": "sm_90412",
  "lead_id": "4417203",
  "property_id": "1658203",
  "status": "approved"
}
```

### dismiss_safe_mode_request

Decline a Safe Mode viewing request. Access: write, asks the user first. REST: `POST /api/v1/rently/dismiss_safe_mode_request`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `request_id` | string | yes | Request ID from list_safe_mode_requests. |

Declines one pending Safe Mode request, so the prospect gets no access to the property. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "request_id": "sm_90415",
  "lead_id": "4417390",
  "status": "dismissed"
}
```

### create_visitor_access_code

Visitor Access Code for one showing date, sent to the visitor by email. Access: write, asks the user first. REST: `POST /api/v1/rently/create_visitor_access_code`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property_id` | string | yes | Property or unit ID from list_properties. |
| `visitor_name` | string | yes | Full name of the visitor. |
| `visitor_phone` | string | yes | Visitor phone number. |
| `visitor_email` | string | yes | The code and instructions go to this email. |
| `showing_date` | date | yes | Day the code works. |
| `description` | string | no | Reason for the visit, e.g. "Plumbing repair". |

Creates a Visitor Access Code for one person and one day at a property, and emails the code and instructions to the visitor. Use it for vendors, inspectors or agents who need to enter once. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "property_id": "1658203",
  "address": "88 Elm Ave, Charlotte, NC",
  "showing_date": "2026-10-12",
  "code_sent_to": "vendor@example.com",
  "status": "sent"
}
```

### send_self_tour_invite

Invite a prospect to self-tour a unit at a set time (multifamily). The invite link is valid for 15 minutes. Access: write, asks the user first. REST: `POST /api/v1/rently/send_self_tour_invite`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `property_id` | string | yes | Property or unit ID from list_properties. |
| `name` | string | yes | Prospect full name. |
| `email` | string | yes | Prospect email. |
| `phone` | string | yes | Prospect phone number. |
| `tour_at` | datetime | yes | Self-tour date and time, ISO 8601 with time zone. |

Sends a prospect an invite to self-tour a unit at a set date and time, for multifamily properties. The invite link is valid for 15 minutes. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "property_id": "1658410",
  "prospect": "maya@example.com",
  "tour_at": "2026-10-13T14:00:00-04:00",
  "link_valid_minutes": 15,
  "status": "sent"
}
```

### ban_prospect

Ban a lead from touring your properties, with a reason. Access: write, asks the user first. REST: `POST /api/v1/rently/ban_prospect`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `lead_id` | string | yes | Lead ID from list_leads. |
| `reason` | string | yes | Why the prospect is banned. |

Bans one lead from touring your properties and stores the reason. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "lead_id": "4417390",
  "status": "banned",
  "reason": "Left a door unlocked during a tour"
}
```

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

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

### Connect Rently to your agent.

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

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

```
Go through the pending Safe Mode requests in Rently. Approve prospects with a phone and email who are not banned and have no complaint in their comments, dismiss anyone who asked to pay a deposit before touring, and leave the rest for me.
```

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

```
curl https://cotlet.dev/api/v1/rently/create_visitor_access_code \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"property_id":"1658203","visitor_name":"Your Plumber","visitor_phone":"+15555550142","visitor_email":"vendor@example.com","showing_date":"2026-10-12","description":"Kitchen sink repair"}'
```

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

```
{
  "property_id": "1658203",
  "address": "88 Elm Ave, Charlotte, NC",
  "showing_date": "2026-10-12",
  "code_sent_to": "vendor@example.com",
  "status": "sent"
}
```

## Why use Cotlet for Rently?

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

## Is there a Rently MCP server on GitHub?

No open-source Rently MCP server exists (checked 11 Oct 2026). What you can use today is Rently itself: tour webhooks and lead reports that your Client Success Manager sets up, which only send data out. Cotlet reads and changes Rently Tour Manager on demand and keeps working when the app changes.

|  | Webhooks and exports | Cotlet |
|---|---|---|
| Setup | Send an endpoint URL to your Client Success Manager, Rently tests and deploys it | Request access, sign in to Rently Tour Manager once in your browser |
| What you get | Tour events pushed to your server, lead reports | Leads, showings, dashboard and listing status on demand |
| Write actions | None: no lead assignment, Safe Mode approvals or invites | Assign leads, approve visits, send invites and codes; sends ask for your OK by default |
| When Rently changes | Rently maintains its own feeds | Our team tests it daily and fixes it for you; failed calls are free |
| Your Rently session | Not applicable, server-to-server | Encrypted in an EU vault, limited to the actions you allow, revoked in one click; if Rently logs you out, your agent gets a link to sign in again |
| Where it runs | Your own server has to receive and store the events | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Included with Rently | 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 Rently 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 Rently API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Rently 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 Rently role do I need?**

Cotlet works in your own Rently Tour Manager account, so it can do what your role can do there. Data exports are limited to Admins and Super Admins.

**Do I need Rently staff to set anything up?**

No. Rently webhooks, lead reports and partner API credentials are set up by your Client Success Manager (checked 11 Oct 2026). Cotlet does not use them; you sign in to Rently once in your browser.

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

No. Every call to grant_safe_mode_access, dismiss_safe_mode_request, create_visitor_access_code, send_self_tour_invite or ban_prospect waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. assign_lead, set_self_touring runs without asking, because it sends nothing to anyone and one call undoes it.

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