# Faire API and MCP server

> Yes, but only part of it: Faire has an External API for brands that covers products, orders and inventory, and a single brand can generate its own access token in the brand portal (checked 11 Oct 2026). We found no API for Messages, Campaigns, your Faire Direct link or your customer list.

Wholesale marketplace where independent brands sell to retail shops: orders, inventory, retailer messages, email campaigns and Faire Direct, the link that brings your own retailers to Faire.

## What is the Faire API?

Cotlet's Faire API exposes 12 endpoints for your own Faire account: list orders, get order, get inventory, list customers, list conversations, get conversation, get Faire Direct link, accept order, add shipment, update inventory, reply to message and send campaign. The list_orders endpoint returns wholesale orders, newest first, with retailer, total, status and ship-by date. Each endpoint takes simple JSON inputs like limit, cursor or order_id and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Local services & SaaS](https://cotlet.dev/integrations/category/local-services-saas)
- **Endpoints:** 12 (7 read, 5 write)
- **Updated:** 2026-10-11

Yes, but only part of it: Faire has an External API for brands that covers products, orders and inventory, and a single brand can generate its own access token in the brand portal (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Faire with 12 endpoints (7 read, 5 write): your AI agent signs in as you and does the work.

## Does Faire have an official API?

Yes, but only part of it: Faire has an External API for brands that covers products, orders and inventory, and a single brand can generate its own access token in the brand portal (checked 11 Oct 2026). We found no API for Messages, Campaigns, your Faire Direct link or your customer list.

| Task | Faire official | Cotlet |
|---|---|---|
| List and read wholesale orders | Yes: External API, orders scope | Yes |
| Accept orders and add shipments | Yes: External API, orders scope | Yes |
| Read and set inventory | Yes: External API, inventory scope | Yes |
| Read and reply to retailer messages | No | Yes |
| List your customers | No | Yes |
| Send email campaigns | No | Yes |
| Get your Faire Direct link | No | Yes |

Sources: [Faire for Developers: External API overview](https://developers.faire.com/docs), [Faire Help Center: How do I get an API key?](https://www.faire.com/support/articles/37632363832091), [Faire Help Center: Accepting an order](https://www.faire.com/support/articles/360006685351), [Faire Help Center: Ship on your own](https://www.faire.com/support/articles/360030933311), [Faire Help Center: Sending email campaigns through Faire](https://www.faire.com/support/articles/360038731612), [Faire Help Center: Can I sync fulfilment information with my Shopify integration?](https://www.faire.com/support/articles/48373321969563), [Faire release notes for brands](https://www.faire.com/blog/for-brands/release-notes/)

## For AI agents

```text
Yes, but only part of it: Faire has an External API for brands that covers products, orders and inventory, and a single brand can generate its own access token in the brand portal (checked 11 Oct 2026). We found no API for Messages, Campaigns, your Faire Direct link or your customer list.
Cotlet provides a hosted MCP server and REST API for Faire: 12 tools (7 read, 5 write).
Access       Request access at https://cotlet.dev/app/signup?app=faire; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/faire
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_orders, get_order, get_inventory, list_customers, list_conversations, get_conversation, get_faire_direct_link, accept_order, add_shipment, update_inventory, reply_to_message, send_campaign
Confirm      accept_order, add_shipment, reply_to_message, send_campaign (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/faire-api-mcp-server.md

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

## What can an AI agent do in Faire?

Cotlet is best for Faire brands who answer retailers and handle orders and campaigns by hand and want an AI agent to do it without running or fixing a server.

- **[Reply to retailer messages](https://cotlet.dev/integrations/faire-api-mcp-server/reply-to-retailer-messages)** (runs: daily): "Go through my Faire Needs Reply threads, check each order or SKU the retailer asks about, and draft a reply for every thread." → `list_conversations`, `get_conversation`, `list_orders`, `get_order`, `get_inventory`, `reply_to_message`
- **Accept new wholesale orders** (runs: daily): "List my new Faire orders and accept the ones I can ship by Friday." → `list_orders`, `get_order`, `get_inventory`, `accept_order`
- **Add tracking numbers to orders** (runs: daily): "Here is today's label export from my shipping app. Match each row to its Faire order and add the tracking number and package cost." → `list_orders`, `get_order`, `add_shipment`
- **[Email retailers who are late to reorder](https://cotlet.dev/integrations/faire-api-mcp-server/email-lapsed-retailers)** (runs: weekly): "Find Faire retailers who are past their usual reorder time, group them by what they last bought and draft one reorder email per group." → `list_customers`, `list_orders`, `get_order`, `send_campaign`

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

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

## Tools

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

### list_orders

Wholesale orders, newest first, with retailer, total, status and ship-by date. Access: read. REST: `POST /api/v1/faire/list_orders`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | string | no | Order status as the portal shows it, e.g. New or Processing. Default: all. |
| `since` | date | no | Only orders placed on or after this date. |
| `retailer_id` | string | no | Only orders from this retailer. |
| `limit` | integer | no | 1 to 100. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists your wholesale orders, newest first. Filter by status or by the date an order was placed to see what is new since your last check. Totals are wholesale prices. Pages hold up to 100 orders; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "orders": [
    {
      "order_id": "bo_8x2k4m9q",
      "retailer": "Example Gift Shop",
      "retailer_id": "r_61d0c3",
      "status": "New",
      "total": 408,
      "currency": "USD",
      "placed_at": "2026-10-08T15:12:00Z",
      "ship_by": "2026-10-16"
    }
  ],
  "next_cursor": null
}
```

### get_order

One order with items, SKUs, quantities, wholesale prices, ship-to address and shipments. Access: read. REST: `POST /api/v1/faire/get_order`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `order_id` | string | yes | Order ID from list_orders, e.g. bo_8x2k4m9q. |

Returns one order in full: each item with SKU, quantity and wholesale price, the ship-to address and any shipments already added. The order total is the sum of the item lines.

Example response:

```json
{
  "order_id": "bo_8x2k4m9q",
  "status": "New",
  "retailer": "Example Gift Shop",
  "items": [
    {
      "sku": "CNDL-AMB-01",
      "name": "Amber candle",
      "quantity": 12,
      "unit_price": 14,
      "line_total": 168
    },
    {
      "sku": "CNDL-CDR-02",
      "name": "Cedar candle",
      "quantity": 12,
      "unit_price": 14,
      "line_total": 168
    },
    {
      "sku": "MTCH-BOX-01",
      "name": "Match box",
      "quantity": 12,
      "unit_price": 6,
      "line_total": 72
    }
  ],
  "total": 408,
  "currency": "USD",
  "ship_to": {
    "city": "Portland",
    "region": "OR",
    "country": "US"
  },
  "shipments": []
}
```

### get_inventory

Available quantity for each product variant, by SKU. Access: read. REST: `POST /api/v1/faire/get_inventory`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `skus` | string[] | no | SKUs to check. Default: all variants. |

Returns the on-hand quantity Faire shows for each variant, keyed by SKU. Pass skus to check only some variants.

Example response:

```json
{
  "items": [
    {
      "sku": "CNDL-AMB-01",
      "quantity": 84
    },
    {
      "sku": "CNDL-CDR-02",
      "quantity": 0
    }
  ]
}
```

### list_customers

Retailers on your customer list with order count and last order date. Access: read. REST: `POST /api/v1/faire/list_customers`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `last_order_before` | date | no | Only retailers whose last order is older than this date. |
| `limit` | integer | no | 1 to 100. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists retailers on your customer list, with how many orders each placed and the date of the last one. Use last_order_before to find retailers who stopped ordering. Pass retailer_id values to send_campaign.

Example response:

```json
{
  "customers": [
    {
      "retailer_id": "r_61d0c3",
      "name": "Example Gift Shop",
      "orders": 3,
      "last_order_at": "2026-04-12"
    },
    {
      "retailer_id": "r_9a3e77",
      "name": "Harbor Home Store",
      "orders": 1,
      "last_order_at": "2026-03-02"
    }
  ],
  "next_cursor": null
}
```

### list_conversations

Conversations in your Messages tab, with retailer, last message and whether a reply is needed. Access: read. REST: `POST /api/v1/faire/list_conversations`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `needs_reply` | boolean | no | Only conversations waiting for your reply. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists your conversations with retailers, most recent first. Set needs_reply to see only the threads waiting for you, the ones the portal groups under Needs Reply.

Example response:

```json
{
  "conversations": [
    {
      "conversation_id": "cv_4f7a21",
      "retailer": "Example Gift Shop",
      "last_message": "When will the candles ship?",
      "needs_reply": true,
      "updated_at": "2026-10-09T10:41:00Z"
    }
  ],
  "next_cursor": null
}
```

### get_conversation

Messages in one conversation with a retailer, oldest first. Access: read. REST: `POST /api/v1/faire/get_conversation`.

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

Returns the messages of one conversation, oldest first, so your agent reads the thread in order before answering. Attachments are listed by file name only.

Example response:

```json
{
  "conversation_id": "cv_4f7a21",
  "retailer": "Example Gift Shop",
  "messages": [
    {
      "from": "retailer",
      "body": "Hi! When will the candles ship?",
      "sent_at": "2026-10-09T10:41:00Z"
    }
  ]
}
```

### get_faire_direct_link

Your Faire Direct link, to share with retailers you already work with. Access: read. REST: `POST /api/v1/faire/get_faire_direct_link`.

No parameters.

Returns the Faire Direct link from your brand portal. A retailer who signs up for Faire through this link can qualify for 0% commission on orders with you. Use it in campaigns and messages.

Example response:

```json
{
  "url": "https://www.faire.com/direct/example-candle-co"
}
```

### accept_order

Accept a new order and set the scheduled ship date. The retailer is notified. Access: write, asks the user first. REST: `POST /api/v1/faire/accept_order`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `order_id` | string | yes | Order ID from list_orders, e.g. bo_8x2k4m9q. |
| `ship_by` | date | yes | Scheduled ship date. |

Accepts one new order with a scheduled ship date. Faire emails the retailer that the order is processing. Replacement orders are not covered by Faire's auto-accept, so use this tool for them. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "order_id": "bo_8x2k4m9q",
  "status": "Processing",
  "ship_by": "2026-10-16"
}
```

### add_shipment

Add carrier, tracking number and package cost to an order. The retailer is notified. Access: write, asks the user first. REST: `POST /api/v1/faire/add_shipment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `order_id` | string | yes | Order ID from list_orders, e.g. bo_8x2k4m9q. |
| `carrier` | string | yes | Carrier name, e.g. UPS or USPS. |
| `tracking_code` | string | yes | Tracking number. |
| `package_cost` | number | yes | Cost of the package. |

Adds a shipment to an order, the same as Ship on your own in the portal: carrier, tracking number and package cost. Faire emails the retailer a tracking link when the order ships. If Faire does not support the carrier, it marks the order shipped on its own 72 hours after the date you added the tracking. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "order_id": "bo_8x2k4m9q",
  "status": "Shipped",
  "shipment": {
    "carrier": "UPS",
    "tracking_code": "1Z999AA10123456784",
    "package_cost": 12.4
  }
}
```

### update_inventory

Set the available quantity of product variants by SKU. Access: write. REST: `POST /api/v1/faire/update_inventory`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `items` | object[] | yes | List of { sku, quantity }. |

Sets the available quantity for one or more variants by SKU, so Faire matches your warehouse. It reaches no one directly and one more call restores the old numbers, so update_inventory runs without asking first.

Example response:

```json
{
  "updated": [
    {
      "sku": "CNDL-AMB-01",
      "quantity": 120
    },
    {
      "sku": "CNDL-CDR-02",
      "quantity": 48
    }
  ]
}
```

### reply_to_message

Send a message as your brand in an existing conversation with a retailer. Access: write, asks the user first. REST: `POST /api/v1/faire/reply_to_message`.

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

Sends a text message in an existing conversation, under your brand name. It cannot start a conversation and cannot attach files; use the portal on desktop for attachments. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "conversation_id": "cv_4f7a21",
  "message_id": "msg_9d20",
  "status": "sent"
}
```

### send_campaign

Send an email campaign to chosen retailers through Faire Campaigns. Access: write, asks the user first. REST: `POST /api/v1/faire/send_campaign`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `subject` | string | yes | Email subject line. |
| `body_markdown` | string | yes | Campaign text. Images by URL. |
| `retailer_ids` | string[] | yes | Recipients from list_customers. |
| `include_faire_direct_link` | boolean | no | Add your Faire Direct link. Default: false. |

Sends an email through Faire's Campaigns tool to the retailers you choose. Sending is free, but Faire limits it: 1 email a week to retailers who have not ordered from you, 2 a week to existing customers, and 1 campaign per retailer per day. Keep the bounce rate under 10% and the spam rate under 0.1% per campaign. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "campaign_id": "cp_30b9",
  "status": "sent",
  "recipients": 3,
  "subject": "Your fall restock is ready"
}
```

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

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

### Connect Faire to your agent.

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

2. **Sign in to Faire once** Open the connect page from the console and sign in to Faire 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 Faire 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 Faire Needs Reply threads, check each order or SKU the retailer asks about, and draft a reply for every thread.
```

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

```
curl https://cotlet.dev/api/v1/faire/add_shipment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"order_id":"bo_8x2k4m9q","carrier":"UPS","tracking_code":"1Z999AA10123456784","package_cost":12.4}'
```

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

```
{
  "order_id": "bo_8x2k4m9q",
  "status": "Shipped",
  "shipment": {
    "carrier": "UPS",
    "tracking_code": "1Z999AA10123456784",
    "package_cost": 12.4
  }
}
```

## Why use Cotlet for Faire?

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

## Is there a Faire MCP server on GitHub?

Faire's External API covers orders, shipments and inventory, and a single brand can generate its own token in the brand portal. You still write and host the code, and the API has no Messages, Campaigns or customer list. Partner connectors built on that API cover orders and stock, not those parts of the portal.

|  | Faire's API (your own app) | Cotlet |
|---|---|---|
| Setup | Generate a token in the brand portal, write and host the code | Request access, sign in to Faire once, add one MCP server or API key |
| Orders and inventory | Documented endpoints for products, orders and inventory | Day-to-day tasks: accept, ship, set stock |
| Messages and campaigns | No API found | Read and answer retailers, send campaigns, each send confirmed by you |
| Your Faire session | An access token that you store and rotate yourself | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When the session expires | Token works until you revoke it | We keep it alive; if Faire logs you out, your agent gets a link to sign in again |
| Upkeep | You update and monitor your own code | Our team tests it daily and fixes it; failed calls are free |
| Price | Free API, paid for with your build 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 Faire 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 Faire API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Faire 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 Faire's API token to use Cotlet?**

No. Cotlet works in your own Faire brand account and does not use an API token. Faire's External API is open to a single brand through a token from the brand portal, but it has no endpoints for Messages or Campaigns (checked 11 Oct 2026).

**Can my agent start a conversation with a retailer?**

No. reply_to_message answers a conversation the retailer already opened, including retailers who write before their first order. To reach retailers who have not written, use send_campaign within the weekly limits Faire sets for campaigns.

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

No. Every call to accept_order, add_shipment, reply_to_message or send_campaign waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. update_inventory runs without asking, because it sends nothing to anyone and one call undoes it.

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