# Peerspace API and MCP server

> Peerspace has no public API, developer portal or webhooks for hosts (checked 11 Oct 2026). The only built-in connection is calendar sync through iCal links or Cronofy, which keeps your availability accurate and nothing more.

Marketplace for renting venues, studios and meeting spaces by the hour, where hosts list spaces and handle inquiries, booking requests, offers and payouts.

## What is the Peerspace API?

Cotlet's Peerspace API exposes 15 endpoints for your own Peerspace account: list listings, list bookings, get booking, list conversations, get conversation, get calendar, list payouts, send message, send custom offer, accept booking request, decline booking request, request booking update, block calendar time, add calendar rate and set Instant Book. The list_listings endpoint returns your spaces and their listings, with base rate, Instant Book and paused status. Each endpoint takes simple JSON inputs like booking_id, listing_id or conversation_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:** 15 (7 read, 8 write)
- **Updated:** 2026-10-11

Peerspace has no public API, developer portal or webhooks for hosts (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Peerspace with 15 endpoints (7 read, 8 write): your AI agent signs in as you and does the work.

## Does Peerspace have an official API?

Peerspace has no public API, developer portal or webhooks for hosts (checked 11 Oct 2026). The only built-in connection is calendar sync through iCal links or Cronofy, which keeps your availability accurate and nothing more.

| Task | Peerspace official | Cotlet |
|---|---|---|
| List booking requests and bookings | No | Yes |
| Read and answer guest messages | No | Yes |
| Send a custom offer (invite to book) | No | Yes |
| Accept or decline booking requests | No | Yes |
| Add calendar rates to a listing | No | Yes |
| Block time on the calendar | Partly: Events marked Busy in a synced Google, Outlook or iCal calendar block time; there is no call to block time directly | Yes |
| List payouts | No: Payouts are on the payout dashboard, with a CSV download of processed payouts | Yes |
| Turn Instant Book on or off | No | Yes |

Sources: [Peerspace help: sync Google, iCloud, Office 365, Exchange or Outlook](https://support.peerspace.com/en/articles/10119392-how-to-sync-google-icloud-office-365-exchange-or-outlook), [Peerspace help: hosts collection](https://support.peerspace.com/en/collections/10899870-hosts), [Peerspace help: send a custom offer with invite-to-book](https://support.peerspace.com/en/articles/11642753-how-to-send-a-custom-offer-using-the-invite-to-book-feature), [Peerspace help: How does Instant Book work?](https://support.peerspace.com/en/articles/10119408-how-does-instant-book-work), [Peerspace help: Instant Book Guidelines](https://support.peerspace.com/en/articles/10119410-instant-book-guidelines), [Peerspace help: Scheduled Messages Feature](https://support.peerspace.com/en/articles/14082065-scheduled-messages-feature), [Peerspace help: Where can I view my calendar?](https://support.peerspace.com/en/articles/10119398-where-can-i-view-my-calendar), [Peerspace help: How do I use the invite-to-book feature?](https://support.peerspace.com/en/articles/10119469-how-do-i-use-the-invite-to-book-feature)

## For AI agents

```text
Peerspace has no public API, developer portal or webhooks for hosts (checked 11 Oct 2026). The only built-in connection is calendar sync through iCal links or Cronofy, which keeps your availability accurate and nothing more.
Cotlet provides a hosted MCP server and REST API for Peerspace: 15 tools (7 read, 8 write).
Access       Request access at https://cotlet.dev/app/signup?app=peerspace; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/peerspace
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_listings, list_bookings, get_booking, list_conversations, get_conversation, get_calendar, list_payouts, send_message, send_custom_offer, accept_booking_request, decline_booking_request, request_booking_update, block_calendar_time, add_calendar_rate, set_instant_book
Confirm      send_message, send_custom_offer, accept_booking_request, decline_booking_request, request_booking_update, block_calendar_time, add_calendar_rate, set_instant_book (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/peerspace-api-mcp-server.md

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

## What can an AI agent do in Peerspace?

Cotlet is best for Peerspace hosts and venue managers who answer inquiries, requests and offers every day without running or fixing a server.

- **[Respond to booking requests before they expire](https://cotlet.dev/integrations/peerspace-api-mcp-server/respond-to-booking-requests)** (runs: daily): "Go through my pending Peerspace booking requests, oldest deadline first. Accept the ones on free slots with 30 people or fewer, ask the guest when the activity is unclear, and show me anything that clashes." → `list_bookings`, `get_booking`, `get_calendar`, `accept_booking_request`, `decline_booking_request`, `send_message`
- **[Reply to Peerspace inquiries](https://cotlet.dev/integrations/peerspace-api-mcp-server/reply-to-inquiries)** (runs: daily): "Answer new Peerspace inquiries: check the date on the calendar, give our rate, parking and load-in details, and ask me about anything you do not know." → `list_conversations`, `get_conversation`, `list_listings`, `get_calendar`, `send_message`
- **[Send a custom offer (invite to book)](https://cotlet.dev/integrations/peerspace-api-mcp-server/send-custom-offer)**: "Turn Dana's inquiry into a Peerspace offer: Oct 24, 10:00 to 18:00, 20 people, at my events rate with the 8+ hour discount, plus the backdrop add-on. Show me the math before you send it." → `list_conversations`, `get_conversation`, `list_listings`, `get_calendar`, `send_custom_offer`
- **Add weekend or evening rates to a listing**: "Add a $150/hour weekend rate to the studio listing." → `list_listings`, `add_calendar_rate`
- **Weekly Peerspace payout report** (runs: weekly): "Every Monday, list my scheduled and processing Peerspace payouts and what is in each." → `list_payouts`

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

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

### list_listings

Your spaces and their listings, with base rate, Instant Book and paused status. Access: read. REST: `POST /api/v1/peerspace/list_listings`.

No parameters.

Returns every listing on your host account with its space, base rate, whether Instant Book is on and whether the listing is live or paused. A paused listing cannot be booked and is hidden from search, and guests cannot contact you about it. Use the IDs here in the other calls.

Example response:

```json
{
  "listings": [
    {
      "listing_id": "l_30918",
      "space_id": "s_4410",
      "title": "Daylight loft studio",
      "base_hourly_rate": 120,
      "instant_book": false,
      "status": "live"
    },
    {
      "listing_id": "l_30922",
      "space_id": "s_4410",
      "title": "Daylight loft, events",
      "base_hourly_rate": 150,
      "instant_book": false,
      "status": "paused"
    }
  ]
}
```

### list_bookings

Booking requests and bookings from the Bookings tab, with guest, date, hours and attendees. Access: read. REST: `POST /api/v1/peerspace/list_bookings`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | requested, confirmed, past or cancelled. Default: requested. |
| `listing_id` | string | no | Only this listing. |
| `from` | date | no | Bookings on or after this date. |
| `to` | date | no | Bookings on or before this date. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists bookings and requests, each with guest first name, start and end, attendees and the status. Requests carry an expires_at, two business days after you received them, so your agent can answer the oldest first. Use booking_id with get_booking, accept_booking_request and decline_booking_request.

Example response:

```json
{
  "bookings": [
    {
      "booking_id": "b_90417",
      "listing_id": "l_30918",
      "guest": "Dana",
      "status": "requested",
      "start": "2026-10-17T14:00:00-07:00",
      "end": "2026-10-17T18:00:00-07:00",
      "attendees": 12,
      "expires_at": "2026-10-14T09:12:00-07:00"
    }
  ],
  "next_cursor": null
}
```

### get_booking

One booking or request: times, attendees, activity, add-ons, price, expected payout and when a request expires. Access: read. REST: `POST /api/v1/peerspace/get_booking`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking or request ID from list_bookings. |

Returns the full record of one booking or request, including the add-ons attached, the price and the payout you expect after Peerspace's service fee. For a request it also returns when it expires. Read it before you accept or decline.

Example response:

```json
{
  "booking_id": "b_90417",
  "listing_id": "l_30918",
  "guest": "Dana",
  "status": "requested",
  "start": "2026-10-17T14:00:00-07:00",
  "end": "2026-10-17T18:00:00-07:00",
  "attendees": 12,
  "activity": "Photo shoot",
  "add_ons": [
    {
      "name": "Backdrop set",
      "price": 50
    }
  ],
  "subtotal": 480,
  "total": 530,
  "expected_payout": 477,
  "expires_at": "2026-10-14T09:12:00-07:00"
}
```

### list_conversations

Inbox threads with guests, with the last message time and whether the guest wrote last. Access: read. REST: `POST /api/v1/peerspace/list_conversations`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `unanswered_only` | boolean | no | Only threads where the guest wrote last. |
| `limit` | integer | no | Maximum threads per page. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists your Peerspace inbox threads, each linked to an inquiry or a booking. Set unanswered_only to get only threads where the guest wrote last, which is what response rate is measured on. Pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "conversations": [
    {
      "conversation_id": "c_58210437",
      "guest": "Dana",
      "about": "inquiry",
      "last_message_at": "2026-10-11T08:40:00-07:00",
      "guest_wrote_last": true
    }
  ],
  "next_cursor": null
}
```

### get_conversation

All messages in a thread, with the inquiry or booking it belongs to. Access: read. REST: `POST /api/v1/peerspace/get_conversation`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `conversation_id` | string | yes | Inbox thread ID from list_conversations. |

Returns the whole thread, oldest message first, with the inquiry or booking it is about. Your agent reads it before replying so it does not repeat an earlier answer.

Example response:

```json
{
  "conversation_id": "c_58210437",
  "about": "inquiry",
  "messages": [
    {
      "from": "guest",
      "sent_at": "2026-10-11T08:40:00-07:00",
      "body": "Hi! Is parking free, and can we shoot on Oct 24?"
    }
  ]
}
```

### get_calendar

Inquiries, requests and bookings for one space, by day. Access: read. REST: `POST /api/v1/peerspace/get_calendar`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `space_id` | string | yes | Space ID from list_listings. |
| `from` | date | yes | First day. |
| `to` | date | yes | Last day. |

Returns what the Peerspace calendar shows for one space between two dates: inquiries, requests and bookings. Inquiries and requests do not block the time, so it still looks open to guests; accepted bookings do. Check it before you accept a request.

Example response:

```json
{
  "space_id": "s_4410",
  "days": [
    {
      "date": "2026-10-17",
      "items": [
        {
          "type": "request",
          "booking_id": "b_90417",
          "start": "14:00",
          "end": "18:00"
        }
      ]
    },
    {
      "date": "2026-10-18",
      "items": [
        {
          "type": "booking",
          "booking_id": "b_90388",
          "start": "10:00",
          "end": "13:00"
        }
      ]
    }
  ]
}
```

### list_payouts

Payouts with date, amount, status and the bookings, overtime and add-ons in each. Access: read. REST: `POST /api/v1/peerspace/list_payouts`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | scheduled, processing or processed. Default: all. |
| `since` | date | no | Only payouts on or after this date. |

Lists the payouts from your payout dashboard. A payout is scheduled 72 hours after the booking ends, becomes processing once initiated and processed after it is paid out. Each entry lists what is inside it, because the payout for a booking and for its overtime can arrive separately.

Example response:

```json
{
  "payouts": [
    {
      "payout_id": "p_7710",
      "status": "scheduled",
      "date": "2026-10-20",
      "amount": 842.5,
      "includes": [
        {
          "type": "booking",
          "booking_id": "b_90388",
          "amount": 800
        },
        {
          "type": "overtime",
          "booking_id": "b_90388",
          "amount": 42.5
        }
      ]
    }
  ]
}
```

### send_message

Reply as you in a guest thread in the Peerspace inbox. Access: write, asks the user first. REST: `POST /api/v1/peerspace/send_message`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `conversation_id` | string | yes | Inbox thread ID from list_conversations. |
| `body` | string | yes | Message text. |

Sends a message in an existing thread under your name; the guest gets it in the Peerspace inbox. It cannot start a thread with a stranger, only answer one. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "message_id": "m_6204188",
  "conversation_id": "c_58210437",
  "status": "sent",
  "sent_at": "2026-10-11T09:05:00-07:00"
}
```

### send_custom_offer

Invite the guest to book with your date, time, attendees and price. The guest has 7 days to pay. Access: write, asks the user first. REST: `POST /api/v1/peerspace/send_custom_offer`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `conversation_id` | string | yes | Inbox thread ID from list_conversations. |
| `start` | datetime | yes | Start, ISO 8601 with time zone. |
| `end` | datetime | yes | End, ISO 8601 with time zone. |
| `attendees` | integer | yes | Number of attendees. |
| `rental_fee` | number | yes | Space rental fee. |
| `minimum_spend` | number | no | Food and beverage minimum, only for spaces that have one. |
| `gratuity` | number | no | Gratuity, only with a food and beverage minimum. |
| `add_on_ids` | string[] | no | Existing add-ons of the listing to include. |
| `note` | string | no | What the offer includes and what the guest can expect. |

Sends an invite-to-book from a guest thread. Spaces without a food and beverage minimum take a rental fee; spaces with one also take minimum spend and gratuity. Sales tax on minimum spend and add-ons is added automatically, so do not include it. The guest then has 7 days to review and submit payment. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "offer_id": "o_7731905",
  "conversation_id": "c_58210437",
  "status": "sent",
  "rental_fee": 900,
  "expires_at": "2026-10-18T09:05:00-07:00"
}
```

### accept_booking_request

Accept a pending request. The booking is confirmed and the guest is charged in full. Access: write, asks the user first. REST: `POST /api/v1/peerspace/accept_booking_request`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking or request ID from list_bookings. |

Accepts a request from the Bookings tab. The booking is confirmed and the guest's card is charged for the full amount. A request you leave alone expires after two business days. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "booking_id": "b_90417",
  "status": "confirmed",
  "start": "2026-10-17T14:00:00-07:00",
  "end": "2026-10-17T18:00:00-07:00",
  "total": 530
}
```

### decline_booking_request

Decline a pending request and release the authorization hold on the guest's card. Access: write, asks the user first. REST: `POST /api/v1/peerspace/decline_booking_request`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking or request ID from list_bookings. |

Declines a request. The authorization hold on the guest's card is released. Declining counts as a response for your response rate, an expired request does not. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "booking_id": "b_90421",
  "status": "declined"
}
```

### request_booking_update

Ask the guest to approve a new date, time, attendee count or price, up to 1 hour before start. Access: write, asks the user first. REST: `POST /api/v1/peerspace/request_booking_update`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking or request ID from list_bookings. |
| `fields` | object | yes | Any of start, end, attendees, subtotal. |

Sends an update request on a confirmed booking; the guest accepts or declines. If they accept, the change applies at once. If they decline, or do not answer within two business days, the original booking stays. If you change the hours, set the new price yourself: it does not update on its own, and 8+ hour discounts do not apply to host updates. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "booking_id": "b_90388",
  "update_id": "u_2045",
  "status": "pending_guest",
  "fields": {
    "end": "2026-10-18T14:00:00-07:00",
    "subtotal": 800
  }
}
```

### block_calendar_time

Block dates and times on a space calendar so guests cannot book them. Access: write, asks the user first. REST: `POST /api/v1/peerspace/block_calendar_time`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `space_id` | string | yes | Space ID from list_listings. |
| `start` | datetime | yes | Start, ISO 8601 with time zone. |
| `end` | datetime | yes | End, ISO 8601 with time zone. |
| `title` | string | no | Private reminder, not shown to guests. |

Blocks the time for all guests, including guests with a pending inquiry or offer. The title is a private reminder that guests cannot see. There is no call to unblock. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "block_id": "blk_5531",
  "space_id": "s_4410",
  "start": "2026-11-03T00:00:00-08:00",
  "end": "2026-11-03T23:59:00-08:00",
  "title": "Maintenance"
}
```

### add_calendar_rate

Rate for chosen days and times on one listing, e.g. weekends or weekday evenings. Access: write, asks the user first. REST: `POST /api/v1/peerspace/add_calendar_rate`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `listing_id` | string | yes | Listing ID from list_listings. |
| `name` | string | yes | Rate name, e.g. Weekend. |
| `hourly_rate` | number | yes | Rate per hour. |
| `days` | string[] | yes | mon, tue, wed, thu, fri, sat, sun. |
| `from_time` | string | no | Start time, HH:MM. |
| `to_time` | string | no | End time, HH:MM. |

Adds a calendar rate to one listing: a name, a rate and the days and times it applies to. Guests see it at checkout once they enter start and end times. Rates far above your base rate can hurt conversion, and Peerspace may remove accounts that use rates to mislead guests. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "listing_id": "l_30918",
  "rate_id": "r_8802",
  "name": "Weekend",
  "hourly_rate": 150,
  "days": [
    "sat",
    "sun"
  ]
}
```

### set_instant_book

Turn Instant Book on or off for one listing, if your account has access. Access: write, asks the user first. REST: `POST /api/v1/peerspace/set_instant_book`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `listing_id` | string | yes | Listing ID from list_listings. |
| `enabled` | boolean | yes | true to turn on, false to turn off. |

Switches the Instant Book toggle for one listing. If the toggle is not available on the listing, the call fails and you need to use Request Access in Peerspace first. You can turn it on or off at any time. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "listing_id": "l_30918",
  "instant_book": true
}
```

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

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

### Connect Peerspace to your agent.

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

2. **Sign in to Peerspace once** Open the connect page from the console and sign in to Peerspace 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 Peerspace 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 my pending Peerspace booking requests, oldest deadline first. Accept the ones on free slots with 30 people or fewer, ask the guest when the activity is unclear, and show me anything that clashes.
```

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

```
curl https://cotlet.dev/api/v1/peerspace/send_custom_offer \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"conversation_id":"c_58210437","start":"2026-10-24T10:00:00-07:00","end":"2026-10-24T16:00:00-07:00","attendees":20,"rental_fee":900,"note":"Six hours for your team offsite, setup from 9:30."}'
```

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

```
{
  "offer_id": "o_7731905",
  "conversation_id": "c_58210437",
  "status": "sent",
  "rental_fee": 900,
  "expires_at": "2026-10-18T09:05:00-07:00"
}
```

## Why use Cotlet for Peerspace?

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

## Is there a Peerspace MCP server on GitHub?

No Peerspace MCP server and no Peerspace app on Zapier turned up (checked 11 Oct 2026). Today the work is done by hand in the Peerspace inbox and Bookings tab, with calendar sync for availability.

|  | By hand in Peerspace | Cotlet |
|---|---|---|
| Setup | None, you work in the Peerspace site or app | Request access, sign in to Peerspace once in your browser, add one MCP server or API key |
| Booking requests | Open each one and accept or decline within two business days | Your agent lists them, summarizes each, and you confirm accept or decline |
| Custom offers | Fill the invite-to-book form per guest | Your agent fills date, time, attendees and price from the thread, you confirm |
| Your Peerspace session | Signed in on your own devices | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When the session expires | You sign in again | If Peerspace logs you out, your agent gets a link to sign in again |
| Where it runs | Browser or phone, one task at a time | 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 Peerspace 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 Peerspace API cost?

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

**Do I need to be technical?**

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

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

**Does a request expire if my agent does not answer it?**

Yes. A Peerspace booking request expires after two business days without an accept or decline, and expired requests lower your response rate (Peerspace help, checked 11 Oct 2026).

**Does Peerspace allow automated access?**

Peerspace Terms of Service, section 2.3, prohibit using any robot, spider or other automatic device to access the Services. Cotlet acts in your signed-in session at your request, and you confirm every call that reaches guests or money by default. Read the terms before you connect an account.

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

No. Every call to send_message, send_custom_offer, accept_booking_request, decline_booking_request, request_booking_update, block_calendar_time, add_calendar_rate or set_instant_book waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals.

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