Movie showtimes MCP server: ask Claude, Cursor or Copilot what’s on

"What's on tonight at the Comoedia?", "where can I see the new Spielberg in original version near Châtelet on Saturday?": with the API Cinéma MCP server, you ask Claude, Cursor or Copilot and it answers with live showtimes. No code to write: one line or a few lines of configuration, and your API key.

› What's on tonight at the Comoedia in Lyon, in VOST?
Claude: Tonight at the Comoedia (Lyon), in original version with subtitles:
Wicker at 18:05 and 20:10, Les Diables at 18:25, Minotaure at 20:30. Booking: cinema-comoedia.com

How it works

MCP (Model Context Protocol) is a standard way to give an AI assistant tools. API Cinéma exposes its API as an MCP server at https://api.api-cinema.com/mcp (Streamable HTTP). The assistant reads the tools, picks the ones it needs and calls them with your key:

The server covers about 2,000 cinemas in France and more than 3,000 in the United States. Times are the local time of each cinema. Every tool call goes through the same checks as the REST API and counts as one request.

What you need

• An API Cinéma key: create a free account, confirm your e-mail address, then create a key from the dashboard. The free plan gives 150 requests a week, enough for personal use: a question costs two or three tool calls.
• An MCP client that sends an Authorization header: Claude Code, Cursor, VS Code with Copilot, Claude Desktop (through a small bridge, see below), or your own code.

Keep the key in an environment variable rather than in the configuration files, so a file shared or committed by mistake does not carry it:

export API_CINEMA_KEY="ac_live_…"   # in ~/.zshrc or ~/.bashrc to keep it

1Claude Code

One command adds the server to your user configuration, available in every project:

claude mcp add --transport http --scope user api-cinema https://api.api-cinema.com/mcp \
  --header "Authorization: Bearer $API_CINEMA_KEY"

To share the server with a team, put it in a .mcp.json file at the root of the project instead. Claude Code expands ${API_CINEMA_KEY} when it starts, so the file holds no secret and can be committed; each developer sets the variable with their own key.

{
  "mcpServers": {
    "api-cinema": {
      "type": "http",
      "url": "https://api.api-cinema.com/mcp",
      "headers": { "Authorization": "Bearer ${API_CINEMA_KEY}" }
    }
  }
}

Start claude in the project, approve the server, and type /mcp to see its six tools. Then ask in plain words: "what's on tonight at the Comoedia in Lyon?".

2Cursor

In ~/.cursor/mcp.json (every project) or .cursor/mcp.json (one project). Cursor resolves ${env:NAME} in headers:

{
  "mcpServers": {
    "api-cinema": {
      "url": "https://api.api-cinema.com/mcp",
      "headers": { "Authorization": "Bearer ${env:API_CINEMA_KEY}" }
    }
  }
}

The server appears under Settings › MCP, with its tools; the agent uses them as soon as a question is about cinemas or films. Cursor reads the environment it was started from: launch it from a terminal where API_CINEMA_KEY is set, or write the key in the file if you keep that file to yourself.

3VS Code with Copilot

In .vscode/mcp.json, VS Code can ask for the key once and keep it in its secret storage, rather than in the file:

{
  "inputs": [
    { "type": "promptString", "id": "api-cinema-key", "description": "API Cinéma key", "password": true }
  ],
  "servers": {
    "api-cinema": {
      "type": "http",
      "url": "https://api.api-cinema.com/mcp",
      "headers": { "Authorization": "Bearer ${input:api-cinema-key}" }
    }
  }
}

Note the top-level servers key: VS Code's format differs from the mcpServers of the other clients. Start the server from the file (the Start link above it), enter the key, then ask Copilot in agent mode.

4Claude Desktop

Claude Desktop connects to remote servers through Custom connectors, which sign in with OAuth; the API Cinéma server takes an API key. The bridge mcp-remote closes the gap: Claude Desktop starts it as a local server, and it forwards every call with your header. In Settings › Developer › Edit Config:

{
  "mcpServers": {
    "api-cinema": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.api-cinema.com/mcp", "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer ac_live_…" }
    }
  }
}

The header is written without a space after the colon and the value comes from env on purpose: some clients split the arguments on spaces when they start npx. Node.js 20 or later must be installed. Restart Claude Desktop: the tools appear under the tools icon of the message box.

5From your own code

Any MCP client library connects the same way. In Node.js, with the official SDK (npm install @modelcontextprotocol/sdk):

import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'

const transport = new StreamableHTTPClientTransport(new URL('https://api.api-cinema.com/mcp'), {
  requestInit: { headers: { Authorization: `Bearer ${process.env.API_CINEMA_KEY}` } },
})
const client = new Client({ name: 'showtimes-script', version: '1.0.0' })
await client.connect(transport)

const { tools } = await client.listTools()
console.log(tools.map(t => t.name).join(', '))

const result = await client.callTool({ name: 'search_cinemas', arguments: { city: 'Lyon', limit: 3 } })
const { data } = JSON.parse(result.content[0].text)
for (const cinema of data)
  console.log(`${cinema.name} (${cinema.slug})`)

await client.close()

node client.js

Each tool returns the JSON of the matching REST endpoint as text, with the same fields as in the documentation. For a script without a model, calling the REST API directly is simpler; the MCP client is the piece you plug into an agent framework that speaks MCP. To build your own chatbot with tools you control, see the chatbot tutorial.

Questions that work well

• "What's on tonight at the Pathé Wepler?" → search_cinemas, then cinema_showtimes.
• "Where is Minotaure showing in original version in Lyon this weekend?" → search_movies, then movie_showtimes with city and version.
• "Cinemas within 5 km of 40.7580, -73.9855 with a screening after 9 pm?" → search_showtimes with lat, lng and from.
• "Which films start between 6 and 7 pm at the Comoedia on Saturday?" → cinema_showtimes with from and to.

Say the city or the country: a name like "Paris" exists in France and in Texas. The tools return 20 results by default, enough for an answer and light on the model's context; ask for more ("the whole week") and the assistant raises limit.

How many requests does it cost?

One per tool call: two or three for a typical question (find the cinema or the film, then its showtimes). The free plan's 150 requests a week cover about fifty questions; for a team or daily use, Starter (€12 a month) gives 10,000 a week. The dashboard shows every call, MCP or REST, on the same usage chart.

Keep the key safe

• The key stays in your client's configuration, on your machine. It is never in the prompt, and the model never sees it: the client adds the header to each call.
• Out of shared files. .mcp.json, .cursor/mcp.json and .vscode/mcp.json are often committed: reference an environment variable or an input there, never the key itself.
• One key per use. A key for your assistant, another for your production app: you can revoke one from the dashboard without cutting the other.
• Read only. Every tool only reads public showtime data; none writes or deletes anything, so an assistant can call them without asking each time.

Going further

• Through the Claude or OpenAI API. Both APIs can call a remote MCP server for you: the Claude Messages API with its MCP connector (mcp_servers, with the key in authorization_token), the OpenAI Responses API with an mcp tool (server_url, with the key in authorization). Your server sends one request, the provider makes the tool calls.
• No-code automations. n8n's MCP Client Tool node takes the same URL, with the key as a header credential: an AI agent that posts "tonight at the cinema" to a channel every evening.
• The registry. The server is listed in the official MCP registry as com.api-cinema/showtimes, so clients that browse the registry find it by name.

Every parameter of the tools is in the documentation; the Python and Next.js tutorials call the same endpoints over REST.