# Connect to Mediafier
> For AI agents and the people using them. Find the client you are running in, then follow its three steps: add, sign in, verify.
- Server URL: `https://mcp.mediafier.ai/mcp` (MCP over Streamable HTTP)
- Sign-in: OAuth in the browser; the client registers itself. Code and agent platforms use an access token instead.
- Access: invite-only before launch. Without an invited account, stop and ask the person to request access at https://mediafier.ai/request-access.
- Never send an organization identifier. Mediafier derives it from the signed-in account.
## Find your client
**Assistant apps**: [Claude Connectors](#claude-connector) · [ChatGPT](#chatgpt-connector) · [Microsoft Copilot Studio](#copilot-studio) · [Microsoft 365 Copilot (declarative agent)](#m365-declarative-agent) · [Slackbot](#slackbot) · [Devin (cloud agent)](#devin-cloud) · [Meta Muse](#meta-muse)
**Coding agents**: [Claude Code CLI (HTTP)](#claude-code-http) · [OpenClaw](#openclaw) · [Hermes Agent](#hermes) · [Codex](#codex-cli) · [Gemini CLI](#gemini-cli) · [GitHub Copilot CLI](#copilot-cli) · [OpenCode](#opencode) · [Goose](#goose) · [Muse Code](#muse-code)
**IDEs**: [Cursor](#cursor) · [VS Code (GitHub Copilot MCP)](#vscode-copilot) · [Devin (formerly Windsurf)](#devin) · [Zed](#zed)
**Your own code and agent platforms**: [Raw MCP (HTTP)](#raw-mcp) · [OpenAI Agents SDK](#openai-agents-sdk) · [Anthropic API (MCP connector)](#anthropic-mcp-connector) · [AWS Bedrock AgentCore](#aws-agentcore) · [Guild](#guild)
Not listed? Any client that accepts a remote MCP server by URL with OAuth can connect: add the server URL above, then use the client's own sign-in step.
## Assistant apps
You cannot change this app's settings yourself. Walk the person through the steps one at a time and wait after each one. Do not take control of their screen.
### Claude Connectors
Status: **Supported**. Verified by hand with a governed call (2026-09-22).
**Add.** Claude → Settings → Connectors → **Add custom connector**. Claude Desktop and the mobile apps share the connectors of your Claude account. Custom connectors may depend on your Claude plan.
```bash
# Claude → Settings → Connectors → Add custom connector
# Paste this Remote MCP server URL, then Connect and sign in:
https://mcp.mediafier.ai/mcp
# Then, in the connector's tool permissions, set Read-only tools to Always allow.
# Read-only tools change nothing and spend nothing; some return short-lived signed links to your own files.
```
**Sign in.** Click **Connect** and sign in to Mediafier in the window that opens.
**Verify.** Follow [Verify](#verify).
### ChatGPT
Status: **Supported**. Verified by hand with a governed call (2026-09-22).
**Add.** ChatGPT → Settings → **Security and login** → **Developer mode** on, then Settings → Apps & Connectors → **Add new connector**. OpenAI's current docs also create it from chatgpt.com/plugins → **+**.
```bash
# Enable Developer Mode: Settings → Security and login → Developer mode
# Then Settings → Apps & Connectors → Add new connector
# Server URL (Authentication: OAuth):
https://mcp.mediafier.ai/mcp
```
**Sign in.** Set Authentication to **OAuth**, create the connector, and sign in to Mediafier in the window that opens.
**Verify.** Follow [Verify](#verify).
### Microsoft Copilot Studio
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** In Copilot Studio, open your agent → **Tools** → **Add a tool** → **New tool** → **Model Context Protocol**. Name it Mediafier, describe what it is for (Copilot uses the description to decide when to call it), paste the server URL, and set Authentication to **OAuth 2.0** → **Dynamic discovery**. The agent needs generative orchestration on. Commercial cloud only.
```bash
# Copilot Studio → your agent → Tools → Add a tool → New tool → Model Context Protocol
# Authentication: OAuth 2.0 → Dynamic discovery
# Server URL:
https://mcp.mediafier.ai/mcp
```
**Sign in.** Set Authentication to **OAuth 2.0** → **Dynamic discovery** (never API key), select **Create**, then **Create a new connection** and sign in to Mediafier in the window that opens, then **Add to agent**. The connection acts as whoever signed in; if the tool offers a choice of credentials, choose the end user's, so each person signs in as themselves. To use the agent in Teams and Microsoft 365 Copilot, publish it and add the **Teams and Microsoft 365 Copilot** channel; making it available to your whole organization may need admin approval.
**Verify.** Follow [Verify](#verify).
### Microsoft 365 Copilot (declarative agent)
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-26).
**Add.** An admin registers an OAuth client in the **Teams Developer Portal** (**Tools** → **OAuth client registration**) with the values below, then uploads the Mediafier app package (provided by Mediafier) to the organization's app catalog. Needs Microsoft 365 Copilot and permission to upload custom apps. Register the client with **no client secret**; if the portal will not save without one, stop: that path is not available yet.
```bash
# Teams Developer Portal → Tools → OAuth client registration → Register client
# Base URL (must equal the agent's server URL):
https://mcp.mediafier.ai/mcp
# Authorization endpoint: /authorize · Token and refresh endpoint: /token (same host as the Base URL)
# Scope: mcp offline_access · PKCE: on · Restrict usage by app: Any Teams app
# Client ID: provided by Mediafier · Client secret: none
```
**Sign in.** Open the Mediafier agent in Microsoft 365 Copilot and select **Sign in to Mediafier** when asked, then finish in the window that opens. Each person signs in as themselves.
**Verify.** Follow [Verify](#verify).
### Slackbot
Status: **Preview**. Not yet verified with Mediafier.
**Add.** Slack → your app → MCP servers → **Add server**. Set it up for your own use: the connection acts as you, so anyone in the workspace who uses it acts as you. For shared team use, use a Mediafier Agent Credential.
```bash
# Slack → your app → MCP servers → Add server
# Paste this server URL, then sign in with your browser:
https://mcp.mediafier.ai/mcp
```
**Sign in.** Sign in to Mediafier in the browser window Slack opens.
**Verify.** Follow [Verify](#verify).
### Devin (cloud agent)
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** app.devin.ai → Customize → MCPs → **Add MCP** → **Add custom MCP**. Adding a server needs the Manage MCP Servers permission; without it you can suggest one to an admin.
```bash
# app.devin.ai → Customize → MCPs → Add MCP → Add custom MCP
# Transport: HTTP · Authentication: OAuth · Access: Personal (recommended)
# Server URL:
https://mcp.mediafier.ai/mcp
```
**Sign in.** Choose **Personal** access, save, then click **Connect** next to the server and sign in to Mediafier. The connection acts as you: with Organization access, everyone in the Devin organization would act as you. For shared team use, use a Mediafier Agent Credential instead.
**Verify.** Follow [Verify](#verify).
### Meta Muse
Status: **Preview**. Not yet verified with Mediafier.
**Add.** Ask Muse in a chat to create a custom connector; Muse walks you through it. Credentials go into its Secure Credentials Store through a prompt separate from the chat.
```bash
# Ask Muse, in a chat:
# Create a custom connector for Mediafier, a remote MCP server
# (Streamable HTTP) at the URL below. Authenticate with OAuth client
# credentials: read token_endpoint and audience from the
# machine_credentials block of /.well-known/agent.json on the same
# host, exchange my client ID and secret for an access token, send
# it as Authorization: Bearer, and get a new one before it expires.
# Ask me for the client ID and secret through your secure credential
# prompt, never in this chat.
# Never paste the secret into the chat: it would stay in the
# conversation history. Enter it only in Muse's credential prompt.
https://mcp.mediafier.ai/mcp
```
**Sign in.** No browser sign-in. An organization admin creates an Agent Credential (Settings → Organization → Agent Credentials); enter its client ID and secret only in Muse's secure credential prompt, never in the chat, where the secret would stay in the conversation history. Muse keeps them in its credential store and exchanges for short-lived access tokens itself; see Authentication & Agent Credentials. The credential acts for your organization, not for you personally, and expires on the date chosen when it was created.
**Verify.** Follow [Verify](#verify).
## Coding agents
You can edit your own MCP configuration and run commands. Keep the person's existing servers; add Mediafier beside them. Pause when the person needs to sign in.
Shortcut: `add-mcp` detects the coding agents and editors installed on this machine and writes the server into each one's configuration. It is a third-party open-source tool, not part of Mediafier, and it does not sign you in: finish each client's **Sign in** step below. For Devin and Zed, use their sections instead: `add-mcp` writes the older Windsurf location for Devin, and a macOS path for Zed that differs from Zed's documentation.
```bash
npx add-mcp https://mcp.mediafier.ai/mcp
```
### Claude Code CLI (HTTP)
Status: **Supported**. Verified automatically in Mediafier's CI (2026-09-22).
**Add.** The command writes `~/.claude.json` (add `--scope project` to write `.mcp.json` instead).
```bash
claude mcp add --transport http mediafier https://mcp.mediafier.ai/mcp
# First run: /mcp in Claude Code, then sign in with your browser.
```
**Sign in.** In Claude Code, type `/mcp`, choose **mediafier**, then **Authenticate**, and finish in the browser. From a shell, `claude mcp login mediafier` does the same. Do not also set an `Authorization` header: with one set, Claude Code reports a 401 as a failed connection instead of starting sign-in.
**Verify.** Follow [Verify](#verify).
### OpenClaw
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** OpenClaw's configuration, under `mcp.servers`.
```json
{
"mcp": {
"servers": {
"mediafier": {
"url": "https://mcp.mediafier.ai/mcp",
"transport": "streamable-http",
"auth": "oauth"
}
}
}
}
```
**Sign in.** Run OpenClaw's login command for the server; OpenClaw's MCP documentation names it.
**Verify.** Follow [Verify](#verify).
### Hermes Agent
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** Hermes Agent's configuration, in its list of MCP servers.
```yaml
# Add a server named mediafier to Hermes Agent's MCP server list:
# url: "https://mcp.mediafier.ai/mcp"
# headers: { Authorization: "Bearer " }
```
**Sign in.** No browser. Put an access token from an Agent Credential in the `Authorization` header; see Authentication & Agent Credentials.
**Verify.** Follow [Verify](#verify).
### Codex
Status: **Supported**. Verified by hand with a governed call (2026-09-18).
**Add.** Run the command below; it writes the server into `~/.codex/config.toml`, which the Codex CLI, the Codex IDE extension and the ChatGPT desktop app share.
```bash
codex mcp add mediafier --url https://mcp.mediafier.ai/mcp
```
**Sign in.** Run `codex mcp login mediafier` and finish in the browser. Some Codex versions start sign-in on `codex mcp add` already; run the login command to sign in again later.
**Verify.** Follow [Verify](#verify).
### Gemini CLI
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** `~/.gemini/settings.json` for all projects, or `.gemini/settings.json` for one; Gemini Code Assist in VS Code reads the same file. Or run `gemini mcp add --transport http -s user mediafier https://mcp.mediafier.ai/mcp`: newer releases write `url` with `"type": "http"` instead of `httpUrl`. Both work on newer releases; only `httpUrl` works on older ones.
```json
{
"mcpServers": {
"mediafier": {
"httpUrl": "https://mcp.mediafier.ai/mcp"
}
}
}
```
**Sign in.** Run `/mcp auth mediafier` in Gemini CLI and finish in the browser. `/mcp auth` on its own lists the servers that still need sign-in.
**Verify.** Follow [Verify](#verify).
### GitHub Copilot CLI
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** The command writes `~/.copilot/mcp-config.json`. A project can use `.mcp.json` or `.github/mcp.json` with the same entry under `mcpServers` (`"type": "http"`, `"url"`).
```bash
copilot mcp add --transport http mediafier https://mcp.mediafier.ai/mcp
```
**Sign in.** Run `/mcp auth` in a Copilot CLI session, choose **mediafier**, and finish in the browser.
**Verify.** Follow [Verify](#verify).
### OpenCode
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** `~/.config/opencode/opencode.json` for all projects, or `opencode.json` / `opencode.jsonc` in the project root.
```json
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"mediafier": {
"type": "remote",
"url": "https://mcp.mediafier.ai/mcp",
"enabled": true
}
}
}
```
**Sign in.** OpenCode asks you to sign in the first time it connects. To sign in directly, run `opencode mcp auth mediafier`; `opencode mcp list` shows the status.
**Verify.** Follow [Verify](#verify).
### Goose
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** `~/.config/goose/config.yaml` on macOS and Linux, `%APPDATA%\Block\goose\config\config.yaml` on Windows. The key is `uri`, not `url`. Or run `goose configure` → Add Extension → Remote Extension (Streamable HTTP).
One-click install: [Add to Goose](goose://extension?url=https%3A%2F%2Fmcp.mediafier.ai%2Fmcp&type=streamable_http&id=mediafier&name=Mediafier&description=Mediafier%20MCP&timeout=300)
```yaml
extensions:
mediafier:
name: mediafier
type: streamable_http
uri: https://mcp.mediafier.ai/mcp
enabled: true
timeout: 300
```
**Sign in.** Goose opens a browser sign-in the first time it uses the server.
**Verify.** Follow [Verify](#verify).
### Muse Code
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** Muse Code's user settings file, `~/.config/muse/settings.json`. The file must declare `"schema_version": 1`, or Muse Code will not start.
```json
// In Muse Code's settings.json (keep "schema_version": 1), add a
// server named mediafier to its MCP server list:
// "mediafier": { "transport": "streamable_http", "url": "https://mcp.mediafier.ai/mcp" }
```
**Sign in.** Run `muse mcp login mediafier` and finish in the browser; Muse Code registers itself, so there is nothing to paste. Run `/mcp` in a session to check that the tools are listed.
**Verify.** Follow [Verify](#verify).
## IDEs
Write the configuration, then ask the person to approve sign-in in the editor. An editor can list the server as connected before anyone has signed in; that is not a working connection.
Shortcut: `add-mcp` detects the coding agents and editors installed on this machine and writes the server into each one's configuration. It is a third-party open-source tool, not part of Mediafier, and it does not sign you in: finish each client's **Sign in** step below. For Devin and Zed, use their sections instead: `add-mcp` writes the older Windsurf location for Devin, and a macOS path for Zed that differs from Zed's documentation.
```bash
npx add-mcp https://mcp.mediafier.ai/mcp
```
### Cursor
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** `~/.cursor/mcp.json` for all projects, or `.cursor/mcp.json` for one project.
One-click install: [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=mediafier&config=eyJ1cmwiOiJodHRwczovL21jcC5tZWRpYWZpZXIuYWkvbWNwIn0%3D)
```json
{
"mcpServers": {
"mediafier": {
"url": "https://mcp.mediafier.ai/mcp"
}
}
}
```
**Sign in.** Cursor shows **Needs login** next to the server in its MCP settings. Click it and finish in the browser.
**Verify.** Follow [Verify](#verify).
### VS Code (GitHub Copilot MCP)
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** `.vscode/mcp.json` in the workspace, or run **MCP: Add Server** → **HTTP** from the Command Palette.
One-click install: [Add to VS Code](vscode:mcp/install?%7B%22name%22%3A%22mediafier%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.mediafier.ai%2Fmcp%22%7D)
```json
{
"servers": {
"mediafier": {
"type": "http",
"url": "https://mcp.mediafier.ai/mcp"
}
}
}
```
**Sign in.** Command Palette → **MCP: List Servers** → **mediafier** → **Start Server**, then **Allow** and finish in the browser. VS Code desktop signs in through a local callback; the vscode.dev web fallback is not supported, so sign in from VS Code desktop.
**Verify.** Follow [Verify](#verify).
### Devin (formerly Windsurf)
Status: **Preview**. Not yet verified with Mediafier.
**Add.** `~/.config/devin/mcp_config.json` for all projects, or `.devin/mcp_config.json` in a project; read by the Devin Local agent and the Devin CLI (`devin mcp add -s user mediafier ` writes it). The legacy Cascade agent reads the same global file and names the URL key `serverUrl`; older Windsurf builds read `~/.codeium/windsurf/mcp_config.json`.
```json
{
"mcpServers": {
"mediafier": {
"url": "https://mcp.mediafier.ai/mcp",
"transport": "http"
}
}
}
```
**Sign in.** Run `devin mcp login mediafier`, or click **Authenticate** in the Devin Local MCP panel. The panel can show the server as connected before anyone has signed in; tools do not list until you do. A team allowlist can block servers that are not on it.
**Verify.** Follow [Verify](#verify).
### Zed
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-09-24).
**Add.** `~/.config/zed/settings.json` on macOS and Linux, `%APPDATA%\Zed\settings.json` on Windows, or `.zed/settings.json` in a project. Or Settings → AI → MCP Servers → Add Server → Add Remote Server.
```json
{
"context_servers": {
"mediafier": {
"url": "https://mcp.mediafier.ai/mcp"
}
}
}
```
**Sign in.** With no `Authorization` header set, Zed asks you to sign in through the browser when it connects.
**Verify.** Follow [Verify](#verify).
## Your own code and agent platforms
There is no browser. Your code presents an access token obtained from a Mediafier Agent Credential with the OAuth client-credentials flow.
### Raw MCP (HTTP)
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** Your own HTTP client.
```bash
curl -sS https://mcp.mediafier.ai/mcp \
-H 'Authorization: Bearer ' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":"1","method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"mediafier-raw-http","version":"0.1.0"}}}'
```
**Sign in.** No browser. Exchange an Agent Credential for an access token (OAuth client credentials) and send it as `Authorization: Bearer`; see Authentication & Agent Credentials.
**Verify.** Follow [Verify](#verify).
### OpenAI Agents SDK
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** Your TypeScript code, where you construct `MCPServerStreamableHttp`.
```typescript
import { Agent, MCPServerStreamableHttp, run } from "@openai/agents";
const mediafier = new MCPServerStreamableHttp({
name: "Mediafier",
url: "https://mcp.mediafier.ai/mcp",
requestInit: {
headers: { Authorization: "Bearer " },
},
});
try {
await mediafier.connect();
const agent = new Agent({
name: "Assistant",
instructions: "Use the Mediafier tools to help the user.",
mcpServers: [mediafier],
});
const result = await run(agent, "List my Mediafier tools.");
console.log(result.finalOutput);
} finally {
await mediafier.close();
}
```
**Sign in.** No browser. Pass an access token from an Agent Credential in `requestInit.headers`; see Authentication & Agent Credentials.
**Verify.** Follow [Verify](#verify).
### Anthropic API (MCP connector)
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** The Messages API request body, in its list of MCP servers.
```bash
# Send the request with this beta header (the MCP connector needs it):
# anthropic-beta: mcp-client-2025-11-20
# In the Messages API request, add a URL-type MCP server:
# url: https://mcp.mediafier.ai/mcp
# name: mediafier
# authorization_token:
# and a tool of type mcp_toolset with mcp_server_name: mediafier.
# Both halves are required; your code chooses the model.
```
**Sign in.** No browser. Pass an access token from an Agent Credential as `authorization_token`; see Authentication & Agent Credentials.
**Verify.** Follow [Verify](#verify).
### AWS Bedrock AgentCore
Status: **Preview**. Setup follows the client's documentation; not yet run by Mediafier (checked 2026-05-15).
**Add.** The AgentCore gateway target configuration.
```json
{
"targetConfiguration": {
"mcp": {
"mcpServer": {
"endpoint": "https://mcp.mediafier.ai/mcp"
}
}
},
"credentialProviderConfigurations": [
{
"credentialProviderType": "OAUTH",
"credentialProvider": {
"oauthCredentialProvider": {
"providerArn": "",
"scopes": []
}
}
}
]
}
```
**Sign in.** Register an AgentCore OAuth credential provider holding your Agent Credential and reference it by ARN.
**Verify.** Follow [Verify](#verify).
### Guild
Status: **Preview**. Not yet verified with Mediafier.
**Add.** A Guild workspace HTTP MCP integration.
```bash
# Guild → workspace → Integrations → add an HTTP MCP integration
# URL: https://mcp.mediafier.ai/mcp
# Header: Authorization: Bearer
# The token is an Auth0 M2M access token for the MCP audience.
```
**Sign in.** No browser. Store an access token from an Agent Credential on the integration as the `Authorization` header.
**Verify.** Follow [Verify](#verify).
## Before you connect
- Connect only to `https://mcp.mediafier.ai/mcp`. A client that asks for your Mediafier sign-in on any other address is not Mediafier.
- Signing in lets this client act with your Mediafier account's access. Your organization comes from that account, never from the client.
- One-click install links are listed where the client supports them; they fill in the same server URL.
## Verify
1. List tools (`tools/list`). A signed-in account gets one or more tools.
2. Tell the person what works and what still needs them. Quote the trace id Mediafier returns with any error.
## If something fails
- **Tool listing fails, or the response is 401:** no one has signed in yet. Do the client's **Sign in** step; a 401 carries a `WWW-Authenticate` header whose `resource_metadata` link leads the client to sign-in.
- **Signed in, but still refused:** the account may not have access yet. Mediafier is invite-only before launch; ask the person to request access at https://mediafier.ai/request-access. Retrying will not change the outcome.
- **Anything else:** read the error's code and actions, and keep its trace id.
More: [MCP Access](https://docs.mediafier.ai/connect/mcp-access) · [Authentication & Agent Credentials](https://docs.mediafier.ai/connect/authentication) · [Compatibility](https://docs.mediafier.ai/connect/compatibility)