Introduction
MCP server
Connect an AI assistant to your Filmo account. It can use exactly the tools its key or connection allows.
- AI assistant
- Filmo MCP serverapp.
filmo. io - Your Filmo account
MCP (Model Context Protocol) lets an assistant call tools. Filmo's server turns the REST API into 170 tools an assistant can choose from while it answers. Each tool runs one REST operation with the same key, scopes, rate limits and account, so everything you know about the REST API applies.
- 76 read tools look things up: orders, items, contacts, invoices, the calendar.
- 94 write or ask tools change the account or spend credits. Clients should ask before running them.
- 34 are annotated destructive, 25 are flagged to ask a person on every call, and 35 are on the list to put on “ask before running”: see Safe writes.
What you can ask
Link to this section: What you can ask- “Which orders start tomorrow, and for which customers?”
- “Are two units of this lens free from 15 to 17 January?”
- “Create a draft order for this customer and leave a note for the north door.”
Authentication
Link to this section: Authentication| Method | Use it when | Page |
|---|---|---|
API key in Authorization: Bearer | The client sends headers: Claude Code, Cursor, VS Code, Windsurf, Codex, Gemini CLI, Make, n8n, your own code. | Connect |
| OAuth 2.1 with PKCE | The client signs you in: Claude, ChatGPT, and the clients above when you prefer it. An administrator consents. | Authentication |
A call without a credential gets an HTTP 401 that points to the OAuth metadata; the URL above is the only one to use.
What the server tells the assistant
Link to this section: What the server tells the assistantWhen a client connects, the server sends instructions: dates, money, idempotency keys, optimistic locking, rate limits, pagination and how errors arrive. There are two variants. Without a credential it is the generic text below. With a credential it adds a summary of what that key can read and write, and the account's time zone, currency and country. The essentials come first, in the first 2,048 characters, because some clients cut instructions there.
Instructions without a credential
Filmo public API (rental management for audiovisual equipment). Every tool maps to one REST v1 operation and runs with the same credential, scopes, rate limits and tenancy as the REST endpoint.
Retries: writes accept idempotencyKey; resend the same key to retry safely (same key with other arguments: 422 idempotency_key_reused). 4 tools (filmo_orders_line_items_return, filmo_purchase_orders_receive, filmo_treasury_payments_create, filmo_workflows_run) duplicate something irreversible on a blind retry: always send your own UUID with them. Results echo the key in meta.idempotencyKey (the server generates one for those 4 if you omit it), and meta.idempotentReplay is true when you got the stored result of an earlier call.
Errors: a failed call returns isError and, as text, the RFC 9457 problem JSON { type, title, status, code, detail, requestId, errors? }. Branch on code, not on detail. 429 rate_limited carries retryAfter (seconds to wait).
Dates: writes take instants as ISO 8601 with offset; responses use UTC ("Z"). In list tools use dateFilters: { field: { gte, lte, gt, lt, on } }; there a bare day ("2026-10-17") is interpreted in the business timezone of the account: the start of that day for gte/on, the end of that day for lte; gt means after the end of that day, lt before its start. An instant with offset is applied as is, except with on, which covers the whole business day that contains it.
Money: decimal strings ("1234.50") plus the currency of the document. Ids are opaque strings. Detail reads return meta.etag; pass it as ifMatch on a write to get 412 precondition_failed instead of overwriting a newer change.
No credential was presented during discovery, so this list is the full catalogue: at call time each tool requires the scope named in its description, and some require an add-on on the account.
Rate limits: 120 calls per minute per credential across all tools, plus a separate 30 per minute shared by the availability tools. Every result carries the quota left in meta.rateLimit { limit, remaining, reset }.
Lists are paginated: pass pagination.nextCursor back as cursor, keeping the same limit (default 50, maximum 500); set includeTotal to true when you need pagination.total; every list tool but the unavailabilities one accepts sort, a comma-separated list of fields with a leading "-" for descending (the tool description names the sortable fields), and the cursor is bound to it.
Error codes: unauthorized and the api_key_* codes (401), insufficient_scope (403) with requiredScope, forbidden (403), addon_required (402) with requiredAddon, validation_error (400, with every field error in errors[]), not_found (404), conflict (409), contact_in_use and address_in_use (409, what uses it counted per type in errors[]), insufficient_stock (409, requested/available/shortfall per item in errors[]), precondition_failed (412), idempotency_key_reused (422), rate_limited (429, with retryAfter), internal_error (500), service_unavailable (503: the feature is switched off for the account; retrying does not help until it is switched on). detail and errors[].message follow the Accept-Language of the MCP request; quote requestId when reporting a problem.Connect a client
Link to this section: Connect a clientAdd Filmo to Claude on the web or the desktop app as a custom connector.
Add Filmo to Claude Code with OAuth, or with an API key that stays out of your repository.
Add Filmo to ChatGPT as a custom MCP server. ChatGPT connects with OAuth only.
Add Filmo to Cursor with OAuth or with an API key read from your environment.
Add Filmo to VS Code (GitHub Copilot agent mode) with OAuth or with an API key it asks for.
Add Filmo to Windsurf's Cascade with an API key read from your environment.
Add Filmo to Codex (CLI and IDE) with OAuth or with an API key read from an environment variable.
Add Filmo to Gemini CLI with OAuth, or with a key kept in your user settings file.
Call Filmo tools from a Make scenario with the MCP Client app.
Give an n8n AI Agent Filmo's tools with the MCP Client Tool node.
Zapier, Raycast, GitHub Copilot, Obsidian, MCP Inspector and any client that speaks MCP over HTTP.
Use the official MCP SDKs or the MCP connectors of the Anthropic and OpenAI APIs.
The contract of this page is the snapshot of 170 REST operations and 170 tools taken on 2026-10-25.
Server URL: https://
| Detail | Value |
|---|---|
| Transport | Streamable HTTP, POST only; stateless, no Mcp-Session-Id. |
| Protocol revision | 2025-06-18 |
| State | Server version 1.. |
| Catalogue | 170 tools, public in tools; with a key, only the ones the key can call. |
| Authentication | API key in the header, or OAuth 2.1 with PKCE and dynamic registration. |
| Relation to REST | Each tool runs exactly one REST operation, with the same key, scopes, limits and tenancy. |
| Capabilities | Tools only: there are no prompts and no resources. |
Permissions
Link to this section: Permissions| Scope | Allows |
|---|---|
*:read | 31 read scopes, 76 tools. List and get records. |
*:write | 26 write scopes, 92 tools. Create, change and delete. |
workflows:run | Run a workflow. |
ai:ask | Ask the account's AI. It spends AI credits. |
Connect a client
Link to this section: Connect a clientclaude mcp add --transport http filmo --scope user https://app.filmo.io/api/v1/mcp \
--header "Authorization: Bearer $FILMO_API_KEY"{
"mcpServers": {
"filmo": {
"url": "https://app.filmo.io/api/v1/mcp",
"headers": {
"Authorization": "Bearer ${env:FILMO_API_KEY}"
}
}
}
}{
"inputs": [
{
"type": "promptString",
"id": "filmo-api-key",
"description": "Filmo API key",
"password": true
}
],
"servers": {
"filmo": {
"type": "http",
"url": "https://app.filmo.io/api/v1/mcp",
"headers": {
"Authorization": "Bearer ${input:filmo-api-key}"
}
}
}
}{
"mcpServers": {
"filmo": {
"serverUrl": "https://app.filmo.io/api/v1/mcp",
"headers": {
"Authorization": "Bearer ${env:FILMO_API_KEY}"
}
}
}
}[mcp_servers.filmo]
url = "https://app.filmo.io/api/v1/mcp"
bearer_token_env_var = "FILMO_API_KEY"{
"mcpServers": {
"filmo": {
"httpUrl": "https://app.filmo.io/api/v1/mcp",
"headers": {
"Authorization": "Bearer <your-filmo-api-key>"
}
}
}
}{
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://app.filmo.io/api/v1/mcp",
"--header",
"Authorization:${FILMO_AUTH}"
],
"env": {
"FILMO_AUTH": "Bearer ${FILMO_API_KEY}"
}
}Related pages
Link to this section: Related pagesIntroduction
MCP quickstart
Connect one assistant, check it with a read tool and choose the scopes it needs.
Access
Authentication and permissions
Authenticate with an API key in a header, or let the client sign in with OAuth 2.1. Either way the scopes decide which tools exist.
Reference
Tool index
Every tool of the server, grouped as in the REST reference. Each one runs exactly one REST operation.
Was this page helpful?