Skip to content

Client setup

Connect Claude, Claude Code, ChatGPT, VS Code, Cursor, or any other MCP client. Same server, same sign-in.

Server

The remote MCP endpoint is:

https://todolistmcp.com/mcp

The client opens that URL over HTTP. When it asks you to sign in, finish in your browser with an email one-time code or Google, then approve the consent screen. This server does not take an API key or a client secret you paste in.

The homepage checklist is the same for every client. These steps are only how each app stores the URL and starts OAuth.

Claude

This is the custom connector on claude.ai. Claude Desktop, Cowork, and the mobile apps use that same connector, because Claude reaches this server from your Claude account. A claude_desktop_config.json entry is a server on your computer, and it is a different setup.

Custom connectors are available on Free, Pro, Max, Team, and Enterprise. A Free account can add one custom connector. On Team and Enterprise, an Owner adds the connector for the organization first. On Enterprise, a custom role that can manage libraries can add it too.

On a Free, Pro, or Max plan:

  1. Open Customize, then Connectors.
  2. Choose + Add, then Add custom connector.
  3. Name it ToDoList MCP.
  4. Remote MCP server URL: https://todolistmcp.com/mcp
  5. Authentication: Sign in now, or Sign in when needed.
  6. OAuth client: Register automatically. Leave the client id and secret empty, and leave request headers empty.
  7. Choose Add. When the browser opens, sign in and allow access.
  8. In a chat, open +, then Connectors, and turn ToDoList MCP on.

Register automatically matches this server. It publishes dynamic client registration. Claude’s published identity is used only when the authorization server also advertises none in token_endpoint_auth_methods_supported. This server does not advertise that field, so Claude falls back to registration. There is no client id on this site to paste under Use your own OAuth client.

On Team or Enterprise, an Owner opens Organization settings, then Connectors, chooses Add, then Custom, then Web, and uses the same URL and the same authentication choices. Each person then opens Customize, then Connectors, and chooses Connect on that connector.

Steps follow Claude’s custom connector guide. The identity fallback is described in Claude’s connector authentication docs.

Claude Code

Run this in a terminal, before you start a claude session. It registers an HTTP server for the current project:

claude mcp add --transport http todolist https://todolistmcp.com/mcp

Add --scope user when you want that server in every project:

claude mcp add --transport http todolist --scope user https://todolistmcp.com/mcp
  1. Start Claude Code.
  2. Run /mcp.
  3. Select todolist and choose Authenticate.
  4. Finish email or Google sign-in and consent in the browser.

Leave off --header and --client-id. This server registers a public client and requires PKCE (S256). Claude Code’s loopback redirect, on localhost or 127.0.0.1 at whatever port it picks, is accepted.

Command and the /mcp authenticate step follow Claude Code’s MCP docs.

ChatGPT

ChatGPT can connect to this remote server with OAuth. OpenAI’s help center adds it from Plugins on ChatGPT on the web. Developer Mode is not part of that setup.

Who can add it, from that same article:

  • Business, Enterprise, and Edu have full MCP, including write tools. On Business, an admin or owner adds the server. On Enterprise and Edu, an admin grants Create plugins with MCPs, and only an admin or owner publishes it for the workspace.
  • Pro can connect a custom MCP server with read and fetch permissions. Write tools are outside that Pro allowance.
  • When Plugins has no Add custom MCP server control, that account cannot connect. This server has no API key to substitute.
  1. Open Plugins.
  2. Choose the plus button, then Add custom MCP server.
  3. Name it ToDoList MCP. A description is optional.
  4. Under Connection, enter https://todolistmcp.com/mcp.
  5. On the authentication step, use OAuth. Leave the client id and secret empty. ChatGPT can register a public client, or present a client metadata document, because this server publishes both.
  6. Check I understand and want to continue.
  7. Choose Create as a plugin. When the browser opens, sign in and approve consent, then wait for the tool list.

This server issues a refresh token with the authorization code and lists refresh_token under grant_types_supported. It does not advertise an offline_access scope. OpenAI says ChatGPT looks for that scope before it keeps a refresh token, so the connection can expire and need sign-in again from Plugins.

The authorization server also does not advertise authorization_response_iss_parameter_supported. ChatGPT then uses a redirect URI for that connection and registers it. You do not copy a redirect URI into this site.

Plan limits and the Plugins steps are from OpenAI’s help center. The OAuth requirements are from OpenAI’s plugin authentication guide.

VS Code

GitHub Copilot in VS Code adds a remote server from the Command Palette. You need Copilot signed in, and a folder open if you save the server with the workspace.

  1. Open the Command Palette and run MCP: Add Server.
  2. Choose HTTP (HTTP or Server-Sent Events).
  3. Enter https://todolistmcp.com/mcp.
  4. Server ID: todolist.
  5. For every workspace, choose Global, then Copilot Global. For one project, choose the workspace file.
  6. When VS Code asks you to sign in, finish it in the browser.

Copilot Global stores the portable format in ~/.copilot/mcp-config.json, or under $COPILOT_HOME when that variable is set:

{
  "mcpServers": {
    "todolist": {
      "type": "http",
      "url": "https://todolistmcp.com/mcp"
    }
  }
}

The VS Code format, in .vscode/mcp.json or the user profile, uses servers:

{
  "servers": {
    "todolist": {
      "type": "http",
      "url": "https://todolistmcp.com/mcp"
    }
  }
}

Leave out headers and oauth.clientId. Those are for a token or a client id a publisher gives you. This server expects the client to register itself and then open the browser.

The picker and the two file formats follow Add MCP servers in VS Code and the MCP configuration reference.

Cursor

Cursor is one client. It uses the same endpoint and the same browser sign-in.

Put this in ~/.cursor/mcp.json for every project, or in .cursor/mcp.json for one project. Customize can add the URL as well.

{
  "mcpServers": {
    "todolist": {
      "url": "https://todolistmcp.com/mcp"
    }
  }
}

Leave out headers and an auth object. Cursor’s CLIENT_ID and CLIENT_SECRET fields are for a server that does not support dynamic client registration. This server does. Save the file, and finish the browser sign-in when Cursor asks.

The url field and the static-OAuth exception are from Cursor’s MCP docs.

Any MCP client

A client that speaks remote MCP over streamable HTTP, and OAuth 2.1 authorization code with PKCE, can connect. Point it at https://todolistmcp.com/mcp.

A call with no bearer token returns 401 and:

WWW-Authenticate: Bearer realm="mcp", resource_metadata="https://todolistmcp.com/.well-known/oauth-protected-resource/mcp"

That protected-resource document sets resource to https://todolistmcp.com/mcp and authorization_servers to https://todolistmcp.com. Advertised scopes are mcp:use, lists:read, lists:write, and lists:share.

https://todolistmcp.com/.well-known/oauth-authorization-server publishes:

  • authorization_endpoint: https://todolistmcp.com/oauth/authorize
  • token_endpoint: https://todolistmcp.com/oauth/token
  • registration_endpoint: https://todolistmcp.com/oauth/register
  • response_types_supported: code
  • grant_types_supported: authorization_code, refresh_token
  • code_challenge_methods_supported: S256
  • client_id_metadata_document_supported: true

It does not publish token_endpoint_auth_methods_supported, authorization_response_iss_parameter_supported, or an offline_access scope.

  1. Read the 401 and those two documents.
  2. Register a public client with POST /oauth/register as JSON (client_name, redirect_uris). The created client uses token_endpoint_auth_method none. Or send an https client metadata document URL as client_id. That document has to name a public client and the authorization code grant. Loopback redirects on localhost, 127.0.0.1, and ::1 are accepted, including when the document omits the port.
  3. Send the person to /oauth/authorize with response_type=code, PKCE S256, and the redirect URI.
  4. They sign in with an email one-time code or Google and approve consent. A sign-in that the client did not start does not connect the client.
  5. Exchange the code at /oauth/token as application/x-www-form-urlencoded, with the code_verifier. Registration stays JSON.
  6. Call /mcp with Authorization: Bearer and the access token. Refresh with grant_type=refresh_token.

A client that can only store an API key, or that needs a client secret created in a dashboard, cannot connect. This site does not issue either one.