{
    "info": {
        "name": "Monotree Partners API",
        "description": "Run your Monotree partnership from your own system: sign up customers and follow them to live, change, suspend and\ncancel them, credit them to your sellers, read their statistics and your monthly statement, answer their support\nthreads, and hear about every change through signed webhooks. A few things stay in the portal, such as a person's\nown password and two-factor sign-in; the guide \"Run everything from your own system\" lists them.\n\nYou may make 120 requests a minute. The count is per partner and mode: all your live tokens share one count and\nall your sandbox tokens another. A few calls that send email or ask Monotree's people for something have a lower\nlimit of their own. A refused call answers `429 rate_limited` with a `Retry-After` header; the guide \"Rate\nlimits\" has the numbers.\n\nEvery `GET` refuses a query parameter it does not take with `422 validation_error`, naming it in `fields`: a typo\nin a filter never returns the whole list. In a JSON body, fields we do not know are ignored. A body that is not\nvalid JSON answers `400 invalid_json`.\n",
        "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
        "version": "1.0.0"
    },
    "auth": {
        "type": "bearer",
        "bearer": [
            {
                "key": "token",
                "value": "{{token}}",
                "type": "string"
            }
        ]
    },
    "variable": [
        {
            "key": "baseUrl",
            "value": "https://partners.monotree.com/api/v1"
        },
        {
            "key": "token",
            "value": "mpt_test_\u2026"
        }
    ],
    "item": [
        {
            "name": "Customers",
            "description": "The companies you sign up. A customer is created, set up and live in about a minute. Wherever a path takes a customer's ID (`cus_\u2026`), you can send `external_ref:` followed by your own reference instead, such as `/customers/external_ref:org_48213`.",
            "item": [
                {
                    "name": "List customers",
                    "request": {
                        "method": "GET",
                        "description": "Your customers, newest first by when they were created (lists cannot be sorted another way). Deleted customers are left out unless you ask for them with `status=deleted`. To check a copy on your side, ask for `updated_since` the time of your last call. Each customer in the list is the whole customer, as Get a customer returns it.",
                        "url": {
                            "raw": "{{baseUrl}}/customers",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "status",
                                    "value": "live,suspended",
                                    "disabled": true
                                },
                                {
                                    "key": "updated_since",
                                    "value": "2026-11-14T08:00:00Z",
                                    "disabled": true
                                },
                                {
                                    "key": "created_after",
                                    "value": "2026-11-01T00:00:00Z",
                                    "disabled": true
                                },
                                {
                                    "key": "country",
                                    "value": "",
                                    "disabled": true
                                },
                                {
                                    "key": "seller",
                                    "value": "external_ref:usr_20503",
                                    "disabled": true
                                },
                                {
                                    "key": "adoption",
                                    "value": "",
                                    "disabled": true
                                },
                                {
                                    "key": "external_ref",
                                    "value": "org_48213",
                                    "disabled": true
                                },
                                {
                                    "key": "q",
                                    "value": "bistro",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Create a customer",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": false
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Creates the customer and starts setting it up at once: it is `provisioning`, then `live` in about a minute, and\nits admin gets an invitation by email. Send `draft: true` to only save it and submit it later. The\n`Idempotency-Key` header is required, so a retry after a timeout never creates a second customer.\n",
                        "url": {
                            "raw": "{{baseUrl}}/customers",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"company_name\": \"Boulangerie Martin\",\n    \"company_id\": \"boulangeriemartin\",\n    \"country\": \"FR\",\n    \"employees\": 18,\n    \"default_language\": \"fr\",\n    \"languages\": [\n        \"fr\",\n        \"en\"\n    ],\n    \"admin\": {\n        \"name\": \"Claire Martin\",\n        \"email\": \"claire@boulangeriemartin.example\",\n        \"phone\": \"+33 6 12 34 56 78\"\n    },\n    \"brand\": {\n        \"primary_color\": \"#b45309\"\n    },\n    \"seller_ref\": \"usr_20503\",\n    \"seller_name\": \"Emma Dubois\",\n    \"external_ref\": \"org_48213\",\n    \"terms_accepted\": true\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Find look-alike customers",
                    "request": {
                        "method": "GET",
                        "description": "Customers of yours that look like one you are about to create: the same company under a slightly different name (legal forms such as SARL or Ltd, accents and a typo are seen through), or the same admin email. Drafts are included, deleted customers are not. It is a warning to show a person, never a refusal: creating the customer still works. At most three per kind of match. Send `company_name`, `admin_email` or both.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/duplicates",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                "duplicates"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "company_name",
                                    "value": "Boulangerie Martin SARL",
                                    "disabled": true
                                },
                                {
                                    "key": "admin_email",
                                    "value": "claire@boulangeriemartin.example",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get a customer",
                    "request": {
                        "method": "GET",
                        "description": "One customer with its state and, while it is being set up, the step it is on.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Change a customer",
                    "request": {
                        "method": "PATCH",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Changes the settings of a customer: send only the fields that change. The change is kept at once and Monotree\napplies it to the customer's app, usually within a minute; `changes_pending` is true until then, and a\n`customer.applied` event follows (`customer.apply_failed` if it could not be applied). The company ID cannot\nchange once the customer is submitted, except while its setup is `failed`. An `external_ref` another customer\nof yours already has is refused. A call that changes nothing answers `200` and sends no event.\n",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"languages\": [\n        \"fr\",\n        \"en\",\n        \"es\"\n    ],\n    \"brand\": {\n        \"primary_color\": \"#9a3412\",\n        \"logo_light\": {\n            \"format\": \"svg\",\n            \"content\": \"PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIC8+\"\n        }\n    }\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Cancel a customer",
                    "request": {
                        "method": "DELETE",
                        "description": "A draft is deleted at once (`status: deleted`). Any other customer is cancelled: its employees lose access\nright away and the company with all its data is deleted after 30 days (`delete_after`); a `customer.deleted`\nevent tells you when. Contact Monotree to undo a cancellation before then. Safe to repeat: for a customer that\nis already cancelled or deleted the answer is `200` with the customer, and nothing changes.\n",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Submit a draft",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Starts setting up a customer that was created with `draft: true`. A draft may be unfinished, so this is where everything is checked: the draft must by now hold all that Create a customer requires (`company_id`, `country`, `employees`, `default_language`, `admin.name`, `admin.email`), and the terms must be accepted, when the draft was made or in this call. What is missing is answered with `422` and named in `fields`, as Create a customer names it; fill it in with Update a customer and submit again.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/submit",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "submit"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"terms_accepted\": true\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Suspend a customer",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Pauses a live customer: its employees can no longer sign in, and all data is kept. Resume at any time. Use it, for example, when your customer stops paying you.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/suspend",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "suspend"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"reason\": \"Subscription unpaid\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Resume a customer",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Gives a suspended customer's employees their access back.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/resume",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "resume"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Retry a failed setup",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Starts the setup again for a customer whose setup stopped (`failed`), from the step it stopped on. Fix what `failure_reason` names first, often with [Change a customer](/docs/reference/customers#update-customer).",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/retry",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "retry"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Resend the admin invitation",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Sends the customer's admin a new invitation email. Only for a live customer.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/admin-invite",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "admin-invite"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "List a customer's events",
                    "request": {
                        "method": "GET",
                        "description": "Every event about one customer, with who did what: the same events, in the same shape and with the same filters, as [List events](/docs/reference/events#list-events) with `customer`. Newest first unless `after` or `order` says otherwise. Events are kept for 90 days, and a token only gets the events it may read.",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/events",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "events"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "type",
                                    "value": "customer.live",
                                    "disabled": true
                                },
                                {
                                    "key": "created_after",
                                    "value": "2026-11-14T08:00:00Z",
                                    "disabled": true
                                },
                                {
                                    "key": "after",
                                    "value": "evt_01jcz8wg4h7v3y6n9q2k5m8p1r",
                                    "disabled": true
                                },
                                {
                                    "key": "order",
                                    "value": "",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                }
            ]
        },
        {
            "name": "Company IDs",
            "description": "A company ID is a customer's address (`boulangeriemartin.monotree.com`) and what its employees type in the Monotree app.",
            "item": [
                {
                    "name": "Check a company ID",
                    "request": {
                        "method": "GET",
                        "description": "Whether a company ID is free, and a free one close to it when it is not. `reason` says why not: `taken` (a customer has it), `reserved` (Monotree keeps it for itself) or `invalid` (too short, too long, or other signs than lower-case letters and digits). Check before you create a customer, or let the create call tell you with a `422`.",
                        "url": {
                            "raw": "{{baseUrl}}/company-ids/:name",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "company-ids",
                                ":name"
                            ],
                            "variable": [
                                {
                                    "key": "name",
                                    "value": "boulangeriemartin"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Events",
            "description": "Every event your webhook endpoints were sent, or would have been sent, kept for 90 days. Read them to catch up after your server was down, or to start a new system from what already happened.",
            "item": [
                {
                    "name": "List events",
                    "request": {
                        "method": "GET",
                        "description": "The events of the token's mode (live or sandbox), exactly as their webhooks carried them, whether or not an\nendpoint was listening. Newest first by default. To catch up, send `after` with the `id` of the last event\nyou handled: the events that came after it are returned oldest first, so you can handle them in order and go\non with `next_cursor` until `has_more` is false. Events are kept for 90 days. Test events (`ping`) are not\nin this list. A token only gets the events it may read: besides `customers:read`, `support.*` events\nneed the `support:read` ability, `webhook_endpoint.*` events `webhooks:manage` and `security.*` events\n`security:read` (no `security.*` event is sent yet). Events the token may not read are left out of the\nlist, and answer `404` when asked for by ID.\n",
                        "url": {
                            "raw": "{{baseUrl}}/events",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "events"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "type",
                                    "value": "customer.live",
                                    "disabled": true
                                },
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8",
                                    "disabled": true
                                },
                                {
                                    "key": "created_after",
                                    "value": "2026-11-14T08:00:00Z",
                                    "disabled": true
                                },
                                {
                                    "key": "after",
                                    "value": "evt_01jcz8wg4h7v3y6n9q2k5m8p1r",
                                    "disabled": true
                                },
                                {
                                    "key": "order",
                                    "value": "",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get an event",
                    "request": {
                        "method": "GET",
                        "description": "One event by its `id`, the one in the webhook body and the `Monotree-Event-Id` header. An event the token may not read (see List events) answers `404`.",
                        "url": {
                            "raw": "{{baseUrl}}/events/:event",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "events",
                                ":event"
                            ],
                            "variable": [
                                {
                                    "key": "event",
                                    "value": "evt_01jcz8wg4h7v3y6n9q2k5m8p1r"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Webhooks",
            "description": "Endpoints on your side that Monotree calls when something changes, and the deliveries made to them.",
            "item": [
                {
                    "name": "List webhook endpoints",
                    "request": {
                        "method": "GET",
                        "description": "Your webhook endpoints of the token's mode (live or sandbox), newest first. Only the endpoints the token may touch are listed: those whose events it may all read, both the types an endpoint is subscribed to and the types among the deliveries it still holds. See [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Add a webhook endpoint",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Adds an endpoint for the token's mode: one added with a sandbox token gets sandbox events only. The signing secret is in the answer to this call only; store it. The URL must be https and lead to a public address: one whose host resolves to a private, loopback, link-local or reserved address is refused, here and again on every delivery. At most 10 endpoints per mode. An endpoint is only sent events its maker may read: the token needs the ability that reads each type in `events` (`customers:read` for `customer.*`, `seller.*` and `adoption.*` events, `support:read` for `support.*`, `webhooks:manage` for `webhook_endpoint.*`), and all of them for `*`, which is also what leaving `events` out means. Otherwise the answer is `403` and names the ability that is missing.",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"url\": \"https://api.acme.example/hooks/monotree\",\n    \"description\": \"Back office, production\",\n    \"events\": [\n        \"customer.live\",\n        \"customer.failed\"\n    ]\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Get a webhook endpoint",
                    "request": {
                        "method": "GET",
                        "description": "One endpoint with its health: `failed_24h` and `last_delivery`. The signing secret is not in this answer. A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Change a webhook endpoint",
                    "request": {
                        "method": "PATCH",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Change the URL or the events, or pause it with `active: false`. `active: true` switches a paused endpoint on again, also one Monotree paused because it only failed. New `events` need the abilities that read them, as when [adding one](/docs/reference/webhooks#create-webhook): a token cannot widen an endpoint to events it may not read (`403`). A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints). So a token cannot point, pause or describe an endpoint for events it may not read either.",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"events\": [\n        \"customer.live\",\n        \"customer.failed\",\n        \"customer.cancelled\"\n    ]\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Delete a webhook endpoint",
                    "request": {
                        "method": "DELETE",
                        "description": "Removes the endpoint and its delivery log. Events that happen from now on are no longer sent to it; they stay in [List events](/docs/reference/events#list-events). A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Send a test event",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Sends a `ping` event to the endpoint at once and answers with the delivery: its `status`, your server's `response_code` and `response_body`. A failed test is not retried. At most 10 test events and redeliveries a minute to one endpoint. A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook/test",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook",
                                "test"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Rotate the signing secret",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Gives the endpoint a new signing secret, in the answer to this call only. The secret before it stays valid\nfor `expire_previous_in` seconds: until then every event is signed with both (two `v1` values in\n`Monotree-Signature`), so your server keeps accepting events while you move it to the new secret.\n\nA token only finds an endpoint whose events it may all read; any other endpoint answers `404`\n([Which endpoints a token sees](/docs/webhooks#token-endpoints)): a secret is not rotated by a token that\nmay not read what the secret signs.\n",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook/rotate-secret",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook",
                                "rotate-secret"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"expire_previous_in\": 3600\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "List deliveries",
                    "request": {
                        "method": "GET",
                        "description": "The deliveries to the endpoint, newest first, with the status code your server answered. A delivery is one event sent to one endpoint, with all its tries. Deliveries are kept for 30 days. Ask for one delivery to see the body sent and your server's answer. A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook/deliveries",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook",
                                "deliveries"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": [
                                {
                                    "key": "status",
                                    "value": "",
                                    "disabled": true
                                },
                                {
                                    "key": "event_id",
                                    "value": "evt_01jcz8wg4h7v3y6n9q2k5m8p1r",
                                    "disabled": true
                                },
                                {
                                    "key": "event",
                                    "value": "customer.live",
                                    "disabled": true
                                },
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Redeliver failed deliveries",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Queues the endpoint's failed deliveries of the last 24 hours again, up to 100, for example after your server was down. Each starts over as with Redeliver a delivery, but is sent from the queue rather than at once. A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook/deliveries/redeliver-failed",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook",
                                "deliveries",
                                "redeliver-failed"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Get a delivery",
                    "request": {
                        "method": "GET",
                        "description": "One delivery, with the body sent (`payload`) and the first 2,000 bytes of your server's last answer (`response_body`). A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints).",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook/deliveries/:delivery",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook",
                                "deliveries",
                                ":delivery"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                },
                                {
                                    "key": "delivery",
                                    "value": "whd_01jd1g2h3j4k5m6n7p8q9r0s1t"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Redeliver a delivery",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Sends the delivery again at once and answers with how it went. Works on failed deliveries and on delivered ones, to try a fix on your side. The delivery starts over: same delivery ID, same body and event `id`, attempts from 0, and the usual retries if this try fails. A retry that was planned is replaced, not added to. Refused while the endpoint is paused or a try is being sent. At most 10 redeliveries and test events a minute to one endpoint. A token only finds an endpoint whose events it may all read (the types it is subscribed to and the types among its deliveries); any other endpoint answers `404`: see [Which endpoints a token sees](/docs/webhooks#token-endpoints). The token must be able to read the delivery's event type.",
                        "url": {
                            "raw": "{{baseUrl}}/webhooks/:webhook/deliveries/:delivery/redeliver",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "webhooks",
                                ":webhook",
                                "deliveries",
                                ":delivery",
                                "redeliver"
                            ],
                            "variable": [
                                {
                                    "key": "webhook",
                                    "value": "whe_01jd1f4c8m2p0r6t9w3y5a7c1e"
                                },
                                {
                                    "key": "delivery",
                                    "value": "whd_01jd1g2h3j4k5m6n7p8q9r0s1t"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Sellers",
            "description": "The people at your company who sign up customers. Every customer is credited to one seller.",
            "item": [
                {
                    "name": "List sellers",
                    "request": {
                        "method": "GET",
                        "description": "Everyone at your company, admins and sellers, with what each brought in. Newest first by when they were added; lists cannot be sorted another way. A sandbox token lists test sellers only and a live token never lists them. See [Sellers and attribution](/docs/sellers).",
                        "url": {
                            "raw": "{{baseUrl}}/sellers",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "sellers"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "role",
                                    "value": "seller",
                                    "disabled": true
                                },
                                {
                                    "key": "status",
                                    "value": "invited",
                                    "disabled": true
                                },
                                {
                                    "key": "disabled",
                                    "value": "",
                                    "disabled": true
                                },
                                {
                                    "key": "q",
                                    "value": "emma",
                                    "disabled": true
                                },
                                {
                                    "key": "email",
                                    "value": "emma@acme.example",
                                    "disabled": true
                                },
                                {
                                    "key": "external_ref",
                                    "value": "usr_20503",
                                    "disabled": true
                                },
                                {
                                    "key": "updated_since",
                                    "value": "2026-11-01T00:00:00Z",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Add a seller",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Adds a person and, unless `invite` is false, emails them an invitation to the portal. You never need this call to credit customers to someone: `seller_ref` on a new customer adds a seller without a login by itself. Adding an admin (`role: admin`) also needs the `admins:write` ability. An email address that is in use anywhere else answers `422` with one sentence that does not say where: the answer never tells whose an address is, and calls with `invite: false` are limited to 60 an hour. With a sandbox token a test seller is made: nobody is invited or emailed whatever `invite` says, and the answer has `status: api_only`.",
                        "url": {
                            "raw": "{{baseUrl}}/sellers",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "sellers"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"name\": \"In\u00e8s Roux\",\n    \"email\": \"ines@acme.example\",\n    \"external_ref\": \"usr_20777\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Get a seller",
                    "request": {
                        "method": "GET",
                        "description": "One person, by Monotree's ID (`sel_5`) or by your own reference (`external_ref:usr_20503`). A person of the other mode answers `404`.",
                        "url": {
                            "raw": "{{baseUrl}}/sellers/:seller",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "sellers",
                                ":seller"
                            ],
                            "variable": [
                                {
                                    "key": "seller",
                                    "value": "sel_5"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Change a seller",
                    "request": {
                        "method": "PATCH",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Changes only the fields you send: the name, email address, reference or role, `invite` to the portal, the Monday email, or `disabled`. A disabled person is signed out at once and cannot sign in; their customers stay as they are. Making someone an admin, and changing an admin's email address, role or `disabled` or inviting an admin, also needs the `admins:write` ability. So does changing the email address of anyone who has chosen a password (`status: active`), admin or seller: it is what they sign in with; of anyone who is invited (the invitation would follow the address); and of a seller who has customers. And so does `invite: true` for a seller who has customers and was never invited: whoever accepts sees those customers. With `sellers:write` alone a token gives an address to, and invites, a seller who has no customers yet. A call with `email` counts against the invitation limit of that seller (3 an hour) and 30 address changes an hour for all your sellers. When the address of someone who signs in changes, the old address gets an email saying so, the person is signed out everywhere and any password-reset link they asked for stops working. The last admin who can sign in cannot be disabled or made a seller (`409 last_admin`).",
                        "url": {
                            "raw": "{{baseUrl}}/sellers/:seller",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "sellers",
                                ":seller"
                            ],
                            "variable": [
                                {
                                    "key": "seller",
                                    "value": "sel_5"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"disabled\": true\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Invite a seller",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Emails the seller an invitation to the portal, or sends it again; the link in an earlier invitation stops working. The seller needs an email address (`422` otherwise) and takes no request body. Inviting an admin also needs `admins:write`, and so does a first invitation to a seller who already has customers (one known from `seller_ref`, say): whoever accepts it sees those customers in the portal. Sending an invitation again to the address it went to needs `sellers:write` alone. With a sandbox token nothing is sent and the seller is returned unchanged.",
                        "url": {
                            "raw": "{{baseUrl}}/sellers/:seller/invite",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "sellers",
                                ":seller",
                                "invite"
                            ],
                            "variable": [
                                {
                                    "key": "seller",
                                    "value": "sel_5"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Reset two-factor sign-in",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "For a person who lost their phone and their recovery codes. Turns their two-factor sign-in off, removes their passkeys and signs them out everywhere; they set two-factor sign-in up again the next time they sign in with their password, and get an email saying it was done through the API with the name of your token. Resetting an admin, or anyone who has chosen a password (`status: active`), also needs `admins:write`; in practice that is everyone with something to reset. A seller with nothing to reset is returned unchanged and gets no email. It takes no request body. See [Security and sign-in](/docs/security).",
                        "url": {
                            "raw": "{{baseUrl}}/sellers/:seller/reset-two-factor",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "sellers",
                                ":seller",
                                "reset-two-factor"
                            ],
                            "variable": [
                                {
                                    "key": "seller",
                                    "value": "sel_5"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Security",
            "description": "How your people sign in to the portal: two-factor sign-in, passkeys and the sign-in log.",
            "item": [
                {
                    "name": "List who can sign in",
                    "request": {
                        "method": "GET",
                        "description": "Your people who have a password and are not disabled, each with their two-factor sign-in, passkeys, last sign-in and wrong tries. Newest first by when they were added. Test sellers never sign in, so a sandbox token gets an empty list. See [Security and sign-in](/docs/security).",
                        "url": {
                            "raw": "{{baseUrl}}/security/people",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "security",
                                "people"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "List the sign-in log",
                    "request": {
                        "method": "GET",
                        "description": "Sign-ins, sign-outs, wrong tries and changes to how someone signs in, newest first. Kept 180 days. These are not the [events](/docs/reference/events) your webhook endpoints get: the sign-in log is only read here. A sandbox token gets an empty list.",
                        "url": {
                            "raw": "{{baseUrl}}/security/events",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "security",
                                "events"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "show",
                                    "value": "denied",
                                    "disabled": true
                                },
                                {
                                    "key": "seller",
                                    "value": "external_ref:usr_20503",
                                    "disabled": true
                                },
                                {
                                    "key": "created_after",
                                    "value": "2026-11-14T12:00:00Z",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                }
            ]
        },
        {
            "name": "Statistics",
            "description": "How your live customers use Monotree, from numbers collected every night: one customer, all of them together, and what the numbers mean.",
            "item": [
                {
                    "name": "Get a customer's statistics",
                    "request": {
                        "method": "GET",
                        "description": "How one customer uses Monotree over a period, from the numbers Monotree counts once a night. `totals` are the latest day in the range, `period` and `daily` cover the range. A customer with no numbers in the range (not live yet, or live since today) answers zeros, an empty `daily` and `updated_at: null`. See [Statistics and adoption](/docs/statistics).",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/statistics",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "statistics"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": [
                                {
                                    "key": "range",
                                    "value": "30d",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get a customer's insights",
                    "request": {
                        "method": "GET",
                        "description": "What the numbers mean for one customer, as the Statistics tab of the portal shows it: a verdict with the next thing to do, how far the rollout has come, the customer beside the average of your other live customers, and its weekly active rate day by day. The texts are English and may be reworded; build on the `key`s. A customer that was never live answers `409`. See [Statistics and adoption](/docs/statistics).",
                        "url": {
                            "raw": "{{baseUrl}}/customers/:customer/insights",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "customers",
                                ":customer",
                                "insights"
                            ],
                            "variable": [
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8"
                                }
                            ],
                            "query": [
                                {
                                    "key": "range",
                                    "value": "30d",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get the statistics of all customers",
                    "request": {
                        "method": "GET",
                        "description": "How all your live customers use Monotree together over a period, in the shape of [a customer's statistics](#get-customer-statistics), and each live customer beside the others in `customers_ranked`, the best taken up first. Only customers with the status `live` are counted. The numbers of the Statistics page in the portal. A sandbox token gets the sandbox's customers.",
                        "url": {
                            "raw": "{{baseUrl}}/statistics",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "statistics"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "range",
                                    "value": "30d",
                                    "disabled": true
                                },
                                {
                                    "key": "seller",
                                    "value": "external_ref:usr_20503",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get the headline numbers",
                    "request": {
                        "method": "GET",
                        "description": "Where you stand right now: how many customers are in each state, how the live ones use the app, how many of them have an open adoption alert, and the customers signed in each of the last six months. The numbers on top of the Customers page in the portal. It takes no parameters.",
                        "url": {
                            "raw": "{{baseUrl}}/summary",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "summary"
                            ],
                            "variable": [],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Adoption",
            "description": "Alerts for live customers that stall: few employees signed in, activity dropped, or the numbers stopped coming.",
            "item": [
                {
                    "name": "List adoption alerts",
                    "request": {
                        "method": "GET",
                        "description": "An adoption alert says that a live customer stalls: few of the invited employees signed in, activity dropped, or its numbers stopped coming. Monotree checks every morning at 05:00 UTC; a customer has one open alert at most, and the alert is resolved when the customer recovers or is no longer live. Only the open alerts unless `status` says otherwise. The alert made last comes first. See [Statistics and adoption](/docs/statistics).",
                        "url": {
                            "raw": "{{baseUrl}}/adoption-alerts",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "adoption-alerts"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "status",
                                    "value": "open",
                                    "disabled": true
                                },
                                {
                                    "key": "seller",
                                    "value": "external_ref:usr_20503",
                                    "disabled": true
                                },
                                {
                                    "key": "customer",
                                    "value": "cus_01jcz8w3k1x9q2v7s4e6m0b5n8",
                                    "disabled": true
                                },
                                {
                                    "key": "reason",
                                    "value": "",
                                    "disabled": true
                                },
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get an adoption alert",
                    "request": {
                        "method": "GET",
                        "description": "One alert, open or resolved. While it is open, its `reason` and `message` follow the latest numbers.",
                        "url": {
                            "raw": "{{baseUrl}}/adoption-alerts/:alert",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "adoption-alerts",
                                ":alert"
                            ],
                            "variable": [
                                {
                                    "key": "alert",
                                    "value": "ala_01jd3m5p7r9t1v3x5z7b9d1f3h"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Statement",
            "description": "Your month as Monotree counts it for the statement: live customers and their employees, per seller and per customer.",
            "item": [
                {
                    "name": "Get a month",
                    "request": {
                        "method": "GET",
                        "description": "Your customers in one month as Monotree counts them for the monthly statement: the customers live on the last day of the month, per seller and per customer. Months run on UTC. With `format=csv` (or the header `Accept: text/csv`) the customers come as a CSV file, the same one the portal exports. See [The monthly statement](/docs/statement).",
                        "url": {
                            "raw": "{{baseUrl}}/overview",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "overview"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "month",
                                    "value": "2026-10",
                                    "disabled": true
                                },
                                {
                                    "key": "format",
                                    "value": "json",
                                    "disabled": true
                                },
                                {
                                    "key": "seller",
                                    "value": "external_ref:usr_20503",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "List the last 12 months",
                    "request": {
                        "method": "GET",
                        "description": "The last twelve months, oldest first and this month last: the customers live at the end of each month (right now, for the month that runs) and the customers signed in it. Up to twelve rows: only months [Get a month](#get-overview) answers for, so the list starts at your first month with Monotree when that is less than a year ago. Never paged: the usual list shape, with `has_more` always `false`. `live_customers` of a month is the same number as in [Get a month](#get-overview).",
                        "url": {
                            "raw": "{{baseUrl}}/overview/months",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "overview",
                                "months"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "seller",
                                    "value": "external_ref:usr_20503",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                }
            ]
        },
        {
            "name": "Support threads",
            "description": "The conversations of your support desk: what the employees and admins of your customers ask, in their app or by email. The [support guide](/docs/support) explains the model.",
            "item": [
                {
                    "name": "List support tags",
                    "request": {
                        "method": "GET",
                        "description": "The product areas of the Monotree app a thread can be tagged with, by name. The list is the same for every partner and you cannot add to it. The assistant tags a thread when it reads it; you can change a thread's tags. Every tag comes in one answer: there are no pages.",
                        "url": {
                            "raw": "{{baseUrl}}/support/tags",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "tags"
                            ],
                            "variable": [],
                            "query": []
                        }
                    }
                },
                {
                    "name": "List people you can write to",
                    "request": {
                        "method": "GET",
                        "description": "The people at your customers a thread can be [started](/docs/reference/support-threads#start-support-thread) with by chat: those who have a Support room in their Monotree app and have written to support in it before. Newest first, by when they first wrote. With `customer`, the admin Monotree invited at that customer comes first on the first page, flagged `admin: true`: they can always be written to by mail (`channel: email` and their `email`), also at a new customer where nobody has written yet; their `id` is null until there is a thread with them. Anyone else known by mail only is not listed. People of a customer that is cancelled, deleted or not live yet are not listed: there is no Monotree to write to them in.",
                        "url": {
                            "raw": "{{baseUrl}}/support/people",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "people"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "customer",
                                    "value": "external_ref:org_48213",
                                    "disabled": true
                                },
                                {
                                    "key": "q",
                                    "value": "sophie",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "List support threads",
                    "request": {
                        "method": "GET",
                        "description": "Your customers' support threads without their messages, as the Support page lists them: the thread last written in comes first (by `last_message_at`). Without `view` you get every thread. The filters narrow together. A sandbox token lists the threads of sandbox customers only, and a live token never lists them. `next_cursor` holds the place of the last thread of the page, so a thread written in while you page moves to the top and is not met twice. To keep a copy in step, ask with `updated_since`, or listen to the [support events](/docs/support#events).",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "view",
                                    "value": "open",
                                    "disabled": true
                                },
                                {
                                    "key": "status",
                                    "value": "open",
                                    "disabled": true
                                },
                                {
                                    "key": "channel",
                                    "value": "chat",
                                    "disabled": true
                                },
                                {
                                    "key": "assignee",
                                    "value": "sel_5",
                                    "disabled": true
                                },
                                {
                                    "key": "kind",
                                    "value": "bug",
                                    "disabled": true
                                },
                                {
                                    "key": "priority",
                                    "value": "high",
                                    "disabled": true
                                },
                                {
                                    "key": "tag",
                                    "value": "Invitations",
                                    "disabled": true
                                },
                                {
                                    "key": "customer",
                                    "value": "external_ref:org_48213",
                                    "disabled": true
                                },
                                {
                                    "key": "q",
                                    "value": "invitation",
                                    "disabled": true
                                },
                                {
                                    "key": "updated_since",
                                    "value": "2026-11-14T00:00:00Z",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Start a support thread",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Writes to someone before they wrote, as **Write to a customer** does in the portal. By `chat` to one of a customer's people (find them with [List people](/docs/reference/support-threads#list-support-people)): where that person has a chat thread that is open or waiting, your message goes into it, since it is the same room to them; otherwise a new thread starts. By `email` to an address, always as a new thread. A token can only write to someone it has a reason to know: someone at one of your customers who has written to you before, or the admin Monotree invited at one of your customers that is live or suspended, by the exact address it invited (the admin of the setup, of the last change of admin that was applied, or of the last invitation sent again; an address you changed a moment ago does not count yet, and a draft's never). Nobody else: not a colleague at the admin's mail domain. Any other address answers `409 invalid_state` and nothing is sent. Naming a `customer` narrows the check to that customer. A mail counts against the recipients that may be written to in an hour (1,000 per mode). A new thread waits for the customer (`waiting`) and has nobody assigned.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"channel\": \"chat\",\n    \"customer\": \"external_ref:org_48213\",\n    \"person\": \"per_132\",\n    \"body\": \"Bonjour Sophie, tout va bien ?\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Simulate a customer's message",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Sandbox only. Plays a message as if someone at one of your sandbox customers wrote it, through the same door real messages come in by: it lands in that person's open or waiting thread, reopens one closed within `reopen_days`, or starts a new thread; the assistant drafts; the automatic reply goes out when your sandbox desk is offline; and `support.message.received` (and `support.thread.created` for a new thread) are sent to your sandbox endpoints. The same `name` and `email` again is the same person writing again. Nothing in the sandbox is ever delivered to anyone.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/simulate",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                "simulate"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"customer\": \"external_ref:org_48213\",\n    \"channel\": \"chat\",\n    \"name\": \"Sophie Garnier\",\n    \"email\": \"sophie@boulangeriemartin.example\",\n    \"role\": \"Manager\",\n    \"body\": \"Bonjour, mon invitation ne marche pas.\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Get a support thread",
                    "request": {
                        "method": "GET",
                        "description": "The thread whole: its latest 50 messages oldest first, its notes, its history (who did what, when), what was escalated to Monotree from it, and the assistant's latest draft. Where `has_earlier_messages` is true, [List messages](/docs/reference/support-messages#list-support-messages) has the ones before. Reading a thread over the API does not mark it read.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Change a support thread",
                    "request": {
                        "method": "PATCH",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Close, dismiss or reopen it, give it to one of your people, set its priority, kind and tags, put it aside until later, or tie its sender to a customer. Send only what changes. Closing a chat asks the customer under your last answer whether it helped (if `ask_rating` is on and you answered in the last 7 days). Each change shows in the thread's history under the token's name and sends its own `support.thread.updated` event. The call changes all of it or nothing: when one field is refused (404, 409 or 422), no other field is changed and no event is sent.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"assignee\": \"sel_5\",\n    \"priority\": \"high\",\n    \"tags\": [\n        \"Invitations\",\n        \"Login\"\n    ],\n    \"snoozed_until\": \"2026-11-20T08:00:00Z\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Delete a support thread",
                    "request": {
                        "method": "DELETE",
                        "description": "Removes the thread for good, with its messages, notes, drafts and the files sent with your answers. A last `support.thread.updated` with `change: deleted` is sent. In the portal only an admin can do this, so it needs `support:configure`. To take a thread out of the way and keep it, dismiss it instead.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Merge a thread into another",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "One conversation that became two threads is made one again: the messages, notes, history, drafts, tags and escalations of this thread go over to `into`, and this thread is gone (its ID then answers 404). The thread that stays keeps its own current draft; the drafts that come over count as earlier rounds that were not used (`superseded`). Only two threads of the same person can be merged. The thread that stays is `open` if their last message has no answer, and sends `support.thread.updated` with `change: merged`.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/merge",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "merge"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"into\": \"sth_01m7d1eq5nqnr07hphj298061a\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                }
            ]
        },
        {
            "name": "Support messages",
            "description": "The messages in a support thread: answers, internal notes and attached files.",
            "item": [
                {
                    "name": "List messages",
                    "request": {
                        "method": "GET",
                        "description": "The messages of a thread, always oldest first, a page at a time. Without `after` or `before` you get the latest ones. `before` with the id of the first message you have walks back through a long thread; `after` with the id of the last one gives what is new. `has_more` says whether there are more on that side. This list has no cursor: `next_cursor` is always null.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/messages",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "messages"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": [
                                {
                                    "key": "after",
                                    "value": "msg_01m7d1ajqgwbvenrpw7gz6xn25",
                                    "disabled": true
                                },
                                {
                                    "key": "before",
                                    "value": "msg_01m7d1awpxds8kqrrt6733j0d2",
                                    "disabled": true
                                },
                                {
                                    "key": "limit",
                                    "value": "50",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Answer a support thread",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Sends an answer to the customer, in their Support room or by mail as the thread came. Files go in the same JSON body, base64 encoded: up to 8, together at most 25 MB before encoding. The thread becomes `waiting`; a closed thread opens again; a dismissed one must be reopened first. Monotree delivers the answer, and `delivery.state` says how far it got. With `last_seen_message` nothing is sent when they have written again since (409), so you never answer past a message you have not read. The assistant's drafts that were waiting are marked `superseded`. In a thread by mail an answer is a mail: at most 20 an hour to one thread and 200 an hour in all, and it goes to every address on copy too: at most 60 recipients an hour for one thread and 1,000 for all. By chat: 600 answers an hour. With files: 30 answers an hour and 500 MB of files a day. Only these kinds of file are taken, by the ending of the name: pdf, png, jpg, jpeg, gif, webp, heic, txt, csv, doc, docx, xls, xlsx, ppt, pptx, odt, ods, odp, rtf, mp4, mov, m4a and mp3; the content must be what the ending says, and a zip or any other kind is refused. A name is kept without control characters and at most 120 characters long. For a note only your people read, use [Add a note](/docs/reference/support-messages#add-support-note).",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/messages",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "messages"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"body\": \"Bonjour Sophie, voici le guide.\",\n    \"last_seen_message\": \"msg_01m7d1ajqgwbvenrpw7gz6xn25\",\n    \"attachments\": [\n        {\n            \"name\": \"guide.pdf\",\n            \"content\": \"JVBERi0xLjQK\"\n        }\n    ]\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Send a failed answer again",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "An answer whose `delivery.state` is `failed` is handed to Monotree again. It is the same message, so nothing arrives twice. No body is needed.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/messages/:message/retry",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "messages",
                                ":message",
                                "retry"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                },
                                {
                                    "key": "message",
                                    "value": "msg_01m7d1awpxds8kqrrt6733j0d2"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Add a note",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "A note on the thread for your own people. The customer never sees it, and it does not change the thread's status. Notes come back in the thread's `notes`, oldest first; a note cannot be changed or removed. Sends `support.thread.updated` with `change: noted`.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/notes",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "notes"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"body\": \"Called the manager; she will try again on Monday.\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Download an attachment",
                    "request": {
                        "method": "GET",
                        "description": "The file itself, for a token that may read its thread. This is what `url` points to on a file sent with one of your answers: fetch it with your token in the `Authorization` header. A PNG, JPEG, GIF or WebP picture comes with its own content type; anything else as `application/octet-stream` with the file's name in `Content-Disposition`. A file the customer sent is kept by Monotree: its `url` is that address, and this endpoint redirects to it. The answer says `Cache-Control: private, no-store`: do not keep it in a shared cache.",
                        "url": {
                            "raw": "{{baseUrl}}/support/attachments/:attachment",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "attachments",
                                ":attachment"
                            ],
                            "variable": [
                                {
                                    "key": "attachment",
                                    "value": "att_2"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Support assistant",
            "description": "The assistant that drafts answers for your support desk: its drafts, and what it has been taught.",
            "item": [
                {
                    "name": "List the assistant's drafts",
                    "request": {
                        "method": "GET",
                        "description": "The versions of the assistant's draft for the customer's latest turn (the `round` of the thread's `draft`), the newest version first. The first is the one on the thread as `draft`. Every version comes in one answer: there are no pages. Drafts of earlier rounds are not listed.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/drafts",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "drafts"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Ask for a draft",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Without `from`, asks the assistant for a draft of an answer to the thread as it stands (no body needed). With `from`, asks for another version of that draft: pick among the options of its `questions` in `answers`, say what to change in `note`, or both; a draft that is `stale` can be redone without either. The new draft becomes the thread's `draft`. It may come back `queued` or `running`: `support.thread.updated` with `change: drafted` is sent when the assistant is done, and the draft is then `ready` or `failed`. In the sandbox it is ready at once.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/drafts",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "drafts"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"from\": \"drf_228\",\n    \"note\": \"Shorter, please.\",\n    \"answers\": [\n        {\n            \"q\": \"Should the answer ask which phone they use now, or only if the first step does not help?\",\n            \"a\": \"Ask now\"\n        }\n    ]\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Put a draft aside",
                    "request": {
                        "method": "DELETE",
                        "description": "Marks a draft that is ready and not yet used as not used. Nothing is deleted: the draft stays readable, with `outcome` `discarded`, and the answer is the draft (200, not 204).",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/drafts/:draft",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "drafts",
                                ":draft"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                },
                                {
                                    "key": "draft",
                                    "value": "drf_229"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Send a draft",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Sends a draft that is ready and not yet used as your answer: as the assistant wrote it (no body needed), or with `body` as you changed it. It goes out as an [answer](/docs/reference/support-messages#reply-support-thread) of your token does. The draft's `outcome` then says which: `sent_unchanged`, `edited`, or `replaced` where less than about a third of it was left.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/drafts/:draft/send",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "drafts",
                                ":draft",
                                "send"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                },
                                {
                                    "key": "draft",
                                    "value": "drf_229"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"body\": \"Bonjour Sophie, essayez de vous d\u00e9connecter et de vous reconnecter. Quel t\u00e9l\u00e9phone utilisez-vous ?\",\n    \"last_seen_message\": \"msg_01m7d1b8f34d98pr5q1mnbdcpt\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Agree there is nothing to answer",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            }
                        ],
                        "description": "Where a draft says `no_reply_needed` (a thank-you, say) and you agree, this closes the thread without an answer, with `resolution` `no_reply`. The draft's `outcome` becomes `no_reply_accepted`. No body is needed.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/drafts/:draft/close",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "drafts",
                                ":draft",
                                "close"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                },
                                {
                                    "key": "draft",
                                    "value": "drf_229"
                                }
                            ],
                            "query": []
                        }
                    }
                },
                {
                    "name": "List what the assistant was taught",
                    "request": {
                        "method": "GET",
                        "description": "The assistant's memory: facts about how you work that it reads before every draft for your customers. A fact has a name, a line that says what it is about, and the fact itself. Newest first. A sandbox token has a memory of its own.",
                        "url": {
                            "raw": "{{baseUrl}}/support/memories",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "memories"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "status",
                                    "value": "remembered",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Teach the assistant a fact",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Either write the fact yourself (`name`, `description` and `body`, all three), which the assistant uses from then on, or send only `from_message` with one of your answers and the assistant proposes what it would remember of it: that comes back `proposed`, and counts once you [agree to it](/docs/reference/support-assistant#update-support-memory). An answer can be learned from once.",
                        "url": {
                            "raw": "{{baseUrl}}/support/memories",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "memories"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"name\": \"Employees are added by the admin\",\n    \"description\": \"Employees are added by the customer's admin\",\n    \"body\": \"Only the admin of a customer can add employees: Users, then Invite. Support never adds them.\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Change a fact",
                    "request": {
                        "method": "PATCH",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Changes what you send of a fact and leaves the rest. A proposal becomes a fact with it, even with an empty JSON object as the body: that is how you agree to one.",
                        "url": {
                            "raw": "{{baseUrl}}/support/memories/:memory",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "memories",
                                ":memory"
                            ],
                            "variable": [
                                {
                                    "key": "memory",
                                    "value": "mem_6"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"body\": \"Only the admin of a customer can add employees: Users, then Invite.\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Forget a fact",
                    "request": {
                        "method": "DELETE",
                        "description": "Removes a fact, or turns a proposal down. The assistant no longer reads it.",
                        "url": {
                            "raw": "{{baseUrl}}/support/memories/:memory",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "memories",
                                ":memory"
                            ],
                            "variable": [
                                {
                                    "key": "memory",
                                    "value": "mem_6"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Support escalations",
            "description": "Support threads handed to Monotree because they need a fix or an answer from Monotree.",
            "item": [
                {
                    "name": "Escalate a thread to Monotree",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Hands what the thread is about on to Monotree, your second line: a bug, a feature request, or an investigation into a customer's data. Monotree picks it up and says how it stands (`status`). Where the same thing was escalated already, send only `duplicate_of` and the thread is added to that escalation; nothing new goes to Monotree ([Find similar escalations](/docs/reference/support-escalations#find-similar-support-escalations) shows candidates). The thread must belong to a customer, and keeps its status. Sends `support.escalation.created`, or `support.escalation.updated` for a duplicate. In the sandbox nothing reaches Monotree and the escalation stays `sent`.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/escalations",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "escalations"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"title\": \"Invitation link opens a blank page\",\n    \"category\": \"bug\",\n    \"description\": \"On Android 14 the link in the invitation mail opens a blank page.\",\n    \"tags\": [\n        1\n    ]\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Follow up a released escalation",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "When Monotree releases what was escalated, each thread it came from shows under the `followup` view until someone says what became of it: `told: true` where the customer was (or is being) told, `false` where nobody needs telling. With `draft: true` the assistant also drafts the message that says it has shipped; it becomes the thread's `draft`, for you to [send](/docs/reference/support-assistant#send-support-draft). Only a released escalation can be followed up; before that the call answers 409. Following up twice changes nothing.",
                        "url": {
                            "raw": "{{baseUrl}}/support/threads/:thread/escalations/:escalation/follow-up",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "threads",
                                ":thread",
                                "escalations",
                                ":escalation",
                                "follow-up"
                            ],
                            "variable": [
                                {
                                    "key": "thread",
                                    "value": "sth_01m7d1ajq9w7ak2vnnp8hfdwj8"
                                },
                                {
                                    "key": "escalation",
                                    "value": "esc_01m7d1cbwj6agthjesfk7198t7"
                                }
                            ],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"told\": true,\n    \"draft\": true\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "List escalations",
                    "request": {
                        "method": "GET",
                        "description": "What you have handed on to Monotree, newest first by when it was escalated, each with the threads it came from. A sandbox token lists the escalations of sandbox customers only.",
                        "url": {
                            "raw": "{{baseUrl}}/support/escalations",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "escalations"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                },
                                {
                                    "key": "status",
                                    "value": "released",
                                    "disabled": true
                                },
                                {
                                    "key": "category",
                                    "value": "bug",
                                    "disabled": true
                                },
                                {
                                    "key": "customer",
                                    "value": "external_ref:org_48213",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Find similar escalations",
                    "request": {
                        "method": "GET",
                        "description": "Escalations of yours that Monotree has not yet released or declined and that share a word of four letters or more with the title and description you are about to send. Those of the `category` you name come first (`bug` where you name none), then the newest. At most five, in one answer. Use one as `duplicate_of` rather than sending the same thing twice.",
                        "url": {
                            "raw": "{{baseUrl}}/support/escalations/similar",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "escalations",
                                "similar"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "title",
                                    "value": "Invitation link opens a blank page",
                                    "disabled": true
                                },
                                {
                                    "key": "description",
                                    "value": "On Android 14 the link in the invitation mail opens a blank page.",
                                    "disabled": true
                                },
                                {
                                    "key": "category",
                                    "value": "bug",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get an escalation",
                    "request": {
                        "method": "GET",
                        "description": "One escalation: how it stands at Monotree, and for each thread it came from whether a follow-up is due.",
                        "url": {
                            "raw": "{{baseUrl}}/support/escalations/:escalation",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "escalations",
                                ":escalation"
                            ],
                            "variable": [
                                {
                                    "key": "escalation",
                                    "value": "esc_01m7d1cbwj6agthjesfk7198t7"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Support desk",
            "description": "How your support desk is set up: its settings, whether it is online, and its numbers.",
            "item": [
                {
                    "name": "Get support stats",
                    "request": {
                        "method": "GET",
                        "description": "The numbers of your support desk over a period, as the Stats tab in the portal shows them: new and solved threads, first-answer and solving times, topics, ratings, what became of the assistant's drafts, and what went to Monotree. Every number has a name that stays; labels are in English. A share is a whole percentage, or null where there is nothing to take a share of. A thread you started yourself counts once the customer has written in it; threads dismissed by the desk itself are left out.",
                        "url": {
                            "raw": "{{baseUrl}}/support/stats",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "stats"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "days",
                                    "value": "7",
                                    "disabled": true
                                },
                                {
                                    "key": "customer",
                                    "value": "external_ref:org_48213",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Get the desk's settings",
                    "request": {
                        "method": "GET",
                        "description": "How your support desk is set up: the same settings as the Settings tab of the Support page. A sandbox token reads and changes a sandbox desk of its own, which only threads of sandbox customers go by.",
                        "url": {
                            "raw": "{{baseUrl}}/support/settings",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "settings"
                            ],
                            "variable": [],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Change the desk's settings",
                    "request": {
                        "method": "PATCH",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Changes the settings you send and leaves the rest. In `hours`, send only the days that change: a day left out keeps its hours, and `null` closes a day. A value that is not valid is refused with 422 and nothing is changed.",
                        "url": {
                            "raw": "{{baseUrl}}/support/settings",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "settings"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"auto\": \"drafts\",\n    \"reopen_days\": 14,\n    \"hours\": {\n        \"mon\": [\n            \"08:00\",\n            \"17:00\"\n        ],\n        \"tue\": [\n            \"08:00\",\n            \"17:00\"\n        ],\n        \"wed\": [\n            \"08:00\",\n            \"17:00\"\n        ],\n        \"thu\": [\n            \"08:00\",\n            \"17:00\"\n        ],\n        \"fri\": [\n            \"08:00\",\n            \"16:00\"\n        ],\n        \"sat\": null,\n        \"sun\": null\n    }\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Get whether support is online",
                    "request": {
                        "method": "GET",
                        "description": "Whether your desk is there to answer right now. The office hours (less the holidays) say, unless someone forced it. While the desk is offline, a new thread gets the automatic reply (if `auto_reply` is on).",
                        "url": {
                            "raw": "{{baseUrl}}/support/presence",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "presence"
                            ],
                            "variable": [],
                            "query": []
                        }
                    }
                },
                {
                    "name": "Switch support online or offline",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "`true` or `false` forces the desk online or offline whatever the office hours say; `null` follows the hours again. A forced state ends by itself at `forced_until`: online after an hour (an hour after the last answer one of your people sent in the portal), offline when support opens next. Forcing what the hours already say forces nothing and clears a forced state.",
                        "url": {
                            "raw": "{{baseUrl}}/support/presence",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "support",
                                "presence"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"online\": true\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                }
            ]
        },
        {
            "name": "Tokens",
            "description": "The API tokens of your company.",
            "item": [
                {
                    "name": "List API tokens",
                    "request": {
                        "method": "GET",
                        "description": "Your company's tokens of the calling token's mode, newest first: a live token lists live tokens, a sandbox token sandbox tokens. A token's value is never shown again; you see its `hint`.",
                        "url": {
                            "raw": "{{baseUrl}}/tokens",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "tokens"
                            ],
                            "variable": [],
                            "query": [
                                {
                                    "key": "limit",
                                    "value": "25",
                                    "disabled": true
                                },
                                {
                                    "key": "cursor",
                                    "value": "6Yb0mT9wQ3F7ImlkIjo1MTF9",
                                    "disabled": true
                                }
                            ]
                        }
                    }
                },
                {
                    "name": "Create an API token",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "Idempotency-Key",
                                "value": "{{$guid}}",
                                "disabled": true
                            },
                            {
                                "key": "Content-Type",
                                "value": "application/json"
                            }
                        ],
                        "description": "Creates a token, for example to rotate one without signing in to the portal. The token's value is in this answer only. The new token is of the calling token's mode; a live token may also ask for a sandbox one with `sandbox: true`. A token can only give abilities it has itself, and a token that expires cannot make one that lasts longer: the new token then needs an `expires_at` no later than its own. With `expires_at` the token stops working at that time: calls with it then answer `401 invalid_token`. A token made this way is revoked together with the token that made it.",
                        "url": {
                            "raw": "{{baseUrl}}/tokens",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "tokens"
                            ],
                            "variable": [],
                            "query": []
                        },
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"name\": \"Reporting, read only\",\n    \"abilities\": [\n        \"customers:read\"\n    ],\n    \"expires_at\": \"2027-11-14T00:00:00Z\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    }
                },
                {
                    "name": "Revoke an API token",
                    "request": {
                        "method": "DELETE",
                        "description": "Calls with the token are refused from now on. Every token it created over the API is revoked with it, and every token those created, and so on, whatever their mode. A token may revoke itself, and other tokens of its own mode only: a sandbox token cannot revoke a live one (`404`).",
                        "url": {
                            "raw": "{{baseUrl}}/tokens/:token",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "tokens",
                                ":token"
                            ],
                            "variable": [
                                {
                                    "key": "token",
                                    "value": "tok_7"
                                }
                            ],
                            "query": []
                        }
                    }
                }
            ]
        },
        {
            "name": "Partner",
            "description": "Your company, and the token you are calling with.",
            "item": [
                {
                    "name": "Who am I",
                    "request": {
                        "method": "GET",
                        "description": "Your company (the partner), the token you are calling with and what it may do, and the version of the API. Needs no ability, so it is a good first call to check a token.",
                        "url": {
                            "raw": "{{baseUrl}}/partner",
                            "host": [
                                "{{baseUrl}}"
                            ],
                            "path": [
                                "partner"
                            ],
                            "variable": [],
                            "query": []
                        }
                    }
                }
            ]
        }
    ]
}