# PeoplePerHour API and MCP server

> PeoplePerHour has no public API and no developer docs (checked 12 Oct 2026). Freelancers search projects, send proposals, answer buyers in WorkStreams and raise invoices in the website only; the one built-in alert is an email, instant or daily, from up to 10 saved searches.

Freelance marketplace where buyers post projects, freelancers send proposals or sell fixed-price Offers, and each deal runs in a private WorkStream with messages, files, invoices and escrow payments.

## What is the PeoplePerHour API?

Cotlet's PeoplePerHour API exposes 11 endpoints for your own PeoplePerHour account: search projects, get project, list proposals, list WorkStreams, get WorkStream, list Offers, send proposal, cancel proposal, send message, create invoice and create Offer. The search_projects endpoint returns projects buyers posted, newest first, with title, budget, category and proposal count. Each endpoint takes simple JSON inputs like limit, cursor or workstream_id and works both as an MCP tool for agents and as a REST call for scripts.

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

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

## Does PeoplePerHour have an official API?

PeoplePerHour has no public API and no developer docs (checked 12 Oct 2026). Freelancers search projects, send proposals, answer buyers in WorkStreams and raise invoices in the website only; the one built-in alert is an email, instant or daily, from up to 10 saved searches.

| Task | PeoplePerHour official | Cotlet |
|---|---|---|
| Search new projects | Partly: Saved search email, instant or daily, nothing to call from code | Yes |
| Send a proposal to a project | No | Yes |
| Cancel and re-send a proposal | No | Yes |
| List WorkStreams and read their messages | No | Yes |
| Reply to a buyer in a WorkStream | No | Yes |
| Create an Offer | No | Yes |
| Raise an invoice from a WorkStream | No: AutoPay bills a fixed weekly or monthly amount, set up by the buyer | Yes |

Sources: [PeoplePerHour: How it works for freelancers](https://www.peopleperhour.com/static/how-it-works-seller), [PeoplePerHour Help: Submitting Proposals](https://support.peopleperhour.com/hc/en-us/articles/205217567-Submitting-Proposals), [PeoplePerHour Help: Canceling a proposal](https://support.peopleperhour.com/hc/en-us/articles/205217577-Canceling-a-proposal), [PeoplePerHour Help: Saved Searches](https://support.peopleperhour.com/hc/en-us/articles/205217987-Saved-Searches), [PeoplePerHour Help: Set up AutoPay](https://support.peopleperhour.com/hc/en-us/articles/204922588-Set-up-AutoPay), [PeoplePerHour: Terms of website use](https://www.peopleperhour.com/static/terms-of-website-use)

## For AI agents

```text
PeoplePerHour has no public API and no developer docs (checked 12 Oct 2026). Freelancers search projects, send proposals, answer buyers in WorkStreams and raise invoices in the website only; the one built-in alert is an email, instant or daily, from up to 10 saved searches.
Cotlet provides a hosted MCP server and REST API for PeoplePerHour: 11 tools (6 read, 5 write).
Access       Request access at https://cotlet.dev/app/signup?app=peopleperhour; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/peopleperhour
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        search_projects, get_project, list_proposals, list_workstreams, get_workstream, list_offers, send_proposal, cancel_proposal, send_message, create_invoice, create_offer
Confirm      send_proposal, cancel_proposal, send_message, create_invoice, create_offer (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/peopleperhour-api-mcp-server.md

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

## What can an AI agent do in PeoplePerHour?

Cotlet is best for PeoplePerHour freelancers who want an AI agent to find projects, draft proposals, answer buyers and raise invoices without running or fixing a server.

- **[Find new projects that match my skills](https://cotlet.dev/integrations/peopleperhour-api-mcp-server/find-new-projects)** (runs: daily): "Every morning, check PeoplePerHour for web design projects posted since yesterday, skip anything under £200 or with more than 15 proposals, read the briefs of the rest and give me a shortlist of five with one line on why each fits." → `search_projects`, `get_project`
- **[Write and send proposals](https://cotlet.dev/integrations/peopleperhour-api-mcp-server/send-proposals)** (runs: daily): "Draft proposals for the two landing page projects you shortlisted today, using my Figma portfolio and a 50% deposit, and show me each one before it goes out." → `get_project`, `send_proposal`, `list_proposals`, `cancel_proposal`
- **[Answer buyer messages in WorkStreams](https://cotlet.dev/integrations/peopleperhour-api-mcp-server/reply-to-buyer-messages)** (runs: twice daily): "Twice a day, find WorkStreams where the buyer wrote last, draft a reply to each from the thread history, and flag any that are close to a full working day without an answer." → `list_workstreams`, `get_workstream`, `send_message`
- **[Raise invoices for finished work](https://cotlet.dev/integrations/peopleperhour-api-mcp-server/invoice-finished-work)** (runs: weekly): "Every Friday, go through my active WorkStreams, find jobs the buyer has signed off but I have not invoiced, and draft each invoice for the agreed price." → `list_workstreams`, `get_workstream`, `create_invoice`
- **Re-send a proposal with a new price**: "The buyer on the landing page project asked for a lower price. Cancel my proposal and send a new one at 400." → `list_proposals`, `cancel_proposal`, `send_proposal`

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

Yes. Cotlet does not replace your automation platform: it gives it a PeoplePerHour 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 find new projects that match my skills, 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/peopleperhour/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/peopleperhour/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/peopleperhour/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/peopleperhour/{tool} with your API key. | cron or GitHub Actions. |

## Tools

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

### search_projects

Projects buyers posted, newest first, with title, budget, category and proposal count. Access: read. REST: `POST /api/v1/peopleperhour/search_projects`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | no | Keywords to search for. |
| `since` | datetime | no | Only projects posted after this time. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Returns projects from the same search as the website, newest first. Filter by keyword or by posting time to read only what came in since your last check. Each item has the budget the buyer set; get_project returns the full brief. Pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "projects": [
    {
      "project_id": "pj_48213",
      "title": "Landing page design for a SaaS launch",
      "budget": {
        "amount": 500,
        "currency": "GBP"
      },
      "category": "Design",
      "proposals": 4,
      "posted_at": "2026-10-10T08:12:00Z",
      "url": "https://www.peopleperhour.com/freelance-jobs/design/landing-page-design-for-a-saas-launch-48213"
    }
  ],
  "next_cursor": null
}
```

### get_project

Full project brief with budget, skills and the proposals already sent. Access: read. REST: `POST /api/v1/peopleperhour/get_project`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `project_id` | string | yes | Project ID from search_projects. |

Returns one project with the buyer's full brief, budget, required skills and how many proposals it has. Use it before send_proposal so your agent reads the brief instead of the title.

Example response:

```json
{
  "project_id": "pj_48213",
  "title": "Landing page design for a SaaS launch",
  "brief": "We need a one-page design in Figma for our launch on 1 November. Copy is ready.",
  "budget": {
    "amount": 500,
    "currency": "GBP"
  },
  "skills": [
    "Web design",
    "Figma"
  ],
  "proposals": 4,
  "posted_at": "2026-10-10T08:12:00Z"
}
```

### list_proposals

Proposals you sent, newest first, with project, price and status. Access: read. REST: `POST /api/v1/peopleperhour/list_proposals`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | string | no | Only proposals with this status, for example pending. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the proposals on your account, newest first, with the project, your price and whether the buyer has accepted it. Filter by status to find the ones still waiting. Pass proposal_id to cancel_proposal.

Example response:

```json
{
  "proposals": [
    {
      "proposal_id": "pp_90412",
      "project_id": "pj_48213",
      "project_title": "Landing page design for a SaaS launch",
      "price": 450,
      "status": "pending",
      "sent_at": "2026-10-10T09:30:00Z"
    }
  ],
  "next_cursor": null
}
```

### list_workstreams

Your WorkStream threads with buyer, project and the last message. Access: read. REST: `POST /api/v1/peopleperhour/list_workstreams`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `awaiting_reply` | boolean | no | Only threads where the buyer sent the last message. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists your WorkStreams, most recent first, each with the buyer, the project and a preview of the last message. Set awaiting_reply to see only threads where the buyer wrote last. Use the workstream_id with get_workstream, send_message and create_invoice.

Example response:

```json
{
  "workstreams": [
    {
      "workstream_id": "ws_7731",
      "buyer": "Maria S.",
      "project_title": "Landing page design for a SaaS launch",
      "last_message": "Can you start on Monday?",
      "last_from": "buyer",
      "updated_at": "2026-10-11T07:40:00Z"
    }
  ],
  "next_cursor": null
}
```

### get_workstream

One WorkStream with its messages, proposals and invoices, oldest first. Access: read. REST: `POST /api/v1/peopleperhour/get_workstream`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workstream_id` | string | yes | WorkStream ID from list_workstreams. |

Returns one WorkStream in order, oldest first: messages, the proposals sent in it, invoices raised and file names shared. Read it before replying so your agent sees the whole history with this buyer.

Example response:

```json
{
  "workstream_id": "ws_7731",
  "buyer": "Maria S.",
  "items": [
    {
      "type": "proposal",
      "proposal_id": "pp_90412",
      "price": 450,
      "sent_at": "2026-10-10T09:30:00Z"
    },
    {
      "type": "message",
      "from": "buyer",
      "body": "Can you start on Monday?",
      "sent_at": "2026-10-11T07:40:00Z"
    }
  ]
}
```

### list_offers

Your Offers with title, price and status. Access: read. REST: `POST /api/v1/peopleperhour/list_offers`.

No parameters.

Lists the fixed-price Offers on your profile, newest first, with title, price and whether each is live. Use it to check what you already sell before creating another.

Example response:

```json
{
  "offers": [
    {
      "offer_id": "of_2209",
      "title": "Landing page design in Figma",
      "price": 350,
      "status": "live"
    }
  ]
}
```

### send_proposal

Send a proposal to a project with your brief, price, delivery time and an optional deposit. Access: write, asks the user first. REST: `POST /api/v1/peopleperhour/send_proposal`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `project_id` | string | yes | Project ID from search_projects. |
| `brief` | string | yes | What you will deliver and by when. |
| `price` | number | yes | Your price in the project currency. |
| `delivery_days` | integer | yes | Days to deliver. |
| `deposit_percent` | integer | no | Share of the price to hold in Escrow up front. Default: none. |

Sends a proposal on one project under your name. It takes a brief of what you will deliver, a price, a delivery time and optionally a deposit to hold in Escrow. It counts against your free Proposals for the month; more are bought as Proposal credits. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "proposal_id": "pp_90412",
  "project_id": "pj_48213",
  "status": "pending",
  "price": 450,
  "delivery_days": 7,
  "deposit_percent": 20,
  "workstream_id": "ws_7731",
  "sent_at": "2026-10-10T09:30:00Z"
}
```

### cancel_proposal

Cancel a proposal the buyer has not accepted yet. Access: write, asks the user first. REST: `POST /api/v1/peopleperhour/cancel_proposal`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `proposal_id` | string | yes | Proposal ID from list_proposals. |

Cancels one pending proposal. An accepted proposal cannot be cancelled and the call fails. The buyer sees the proposal withdrawn, so use it before sending a corrected one. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "proposal_id": "pp_90412",
  "status": "cancelled"
}
```

### send_message

Send a message to the buyer in a WorkStream, as you. Access: write, asks the user first. REST: `POST /api/v1/peopleperhour/send_message`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workstream_id` | string | yes | WorkStream ID from list_workstreams. |
| `body` | string | yes | Message text. |

Posts a message in one WorkStream under your name. Each WorkStream is one buyer and one project, so a message never reaches other buyers. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "workstream_id": "ws_7731",
  "message_id": "msg_5120",
  "status": "sent",
  "sent_at": "2026-10-11T08:05:00Z"
}
```

### create_invoice

Raise an invoice in a WorkStream for the buyer to pay. Access: write, asks the user first. REST: `POST /api/v1/peopleperhour/create_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workstream_id` | string | yes | WorkStream ID from list_workstreams. |
| `amount` | number | yes | Invoice amount in the project currency. |
| `description` | string | yes | What the invoice is for. |

Raises an invoice in one WorkStream. The buyer is asked to pay it, so it reaches money and the other person. Amount and description are the ones you pass. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": "inv_3318",
  "workstream_id": "ws_7731",
  "amount": 300,
  "description": "Landing page design, week 2",
  "status": "sent",
  "raised_at": "2026-10-16T16:00:00Z"
}
```

### create_offer

Publish a fixed-price Offer on your profile. Access: write, asks the user first. REST: `POST /api/v1/peopleperhour/create_offer`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `title` | string | yes | Offer title. |
| `description` | string | yes | What the buyer gets. |
| `price` | number | yes | Price in your account currency. |

Publishes an Offer on your profile with a title, description and price, visible to buyers. It reaches the public, so it asks first. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "offer_id": "of_2210",
  "title": "Logo refresh in 3 days",
  "price": 120,
  "status": "live"
}
```

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

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

### Connect PeoplePerHour to your agent.

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

2. **Sign in to PeoplePerHour once** Open the connect page from the console and sign in to PeoplePerHour 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 PeoplePerHour tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Every morning, check PeoplePerHour for web design projects posted since yesterday, skip anything under £200 or with more than 15 proposals, read the briefs of the rest and give me a shortlist of five with one line on why each fits.
```

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

```
curl https://cotlet.dev/api/v1/peopleperhour/send_proposal \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"project_id":"pj_48213","brief":"I will design the landing page in Figma and hand over the files, with two rounds of changes.","price":450,"delivery_days":7,"deposit_percent":20}'
```

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

```
{
  "proposal_id": "pp_90412",
  "project_id": "pj_48213",
  "status": "pending",
  "price": 450,
  "delivery_days": 7,
  "deposit_percent": 20,
  "workstream_id": "ws_7731",
  "sent_at": "2026-10-10T09:30:00Z"
}
```

## Why use Cotlet for PeoplePerHour?

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

## Is there a PeoplePerHour MCP server on GitHub?

Hosted scrapers exist for PeoplePerHour. They read public project and freelancer listings, you pay them per result, and they never see your WorkStreams or send anything as you. Cotlet signs in as you and works in your own account.

|  | Hosted scraper | Cotlet |
|---|---|---|
| Setup | Create an account with the scraper host, set search inputs, add its token to your client | Request access, sign in to PeoplePerHour once in your browser, add one MCP server or API key |
| What it covers | Public project and freelancer listings, read only | Search plus your proposals, WorkStreams, messages, Offers and invoices |
| Your account | Not connected, so it cannot send or reply as you | Works as you: proposals, replies and invoices go out under your name |
| Your session | None, no account is connected | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When PeoplePerHour changes | Maintained by the scraper author | Our team tests it daily and fixes it for you; failed calls are free |
| Where it runs | Hosted by the scraper provider | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Per result | 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 PeoplePerHour 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 PeoplePerHour API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your PeoplePerHour 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 a paid PeoplePerHour plan?**

No plan is needed for Cotlet; it works in your own freelancer account. PeoplePerHour gives each freelancer 15 Proposals a month for free and sells more as Proposal credits.

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

No. Every call to send_proposal, cancel_proposal, send_message, create_invoice or create_offer 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 PeoplePerHour 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/peopleperhour/{tool} from the HTTP Request node.