jess-author

Jessica Temporal is a Senior Developer Advocate at Auth0 and co-founder of the first Brazilian data science podcast called <a target='_blank' href='https://pizzadedados.com'><strong>Pizza de Dados</strong></a>. She’s the author of <a target='_blank' href='https://www.amazon.com/dp/B0CDNX6NS7/ref=sr_1_1?&_encoding=UTF8&tag=jesstempora0e-20&linkCode=ur2&linkId=efc4229f6b816609dfce4f185781d99a&camp=1789&creative=9325' ><strong>The Big Git Microbook</strong></a>, creator of <a target='_blank' href='https://gitfichas.com/en'><strong>GitFichas.com</strong></a>, and a part of <a target='_blank' href='https://www.linkedin.com/learning/instructors/jessica-temporal'><strong>LinkedIn Learning</strong></a> instructors team. Jessica helped develop the AI that identifies possible unlawful expenses from Brazilian politicians. She is part of the PyLadies initiative that works to improve diversity and inclusion in technology. In her free time, she likes to knit, play video games, use her 3D printer, and is learning to create 3D models.

Sr. Developer Advocate

Jessica Temporal

The official Auth0 MCP Server is now available. MCP Hosts can securely manage Auth0 tenant resources using natural language.

**TL;DR:** The official Auth0 MCP Server is available now. We’ll go over how you can use Claude Desktop, Cursor, Windsurf and other MCP Clients to securely manage your Auth0 tenant using natural language. Learn more with [our Get Started guide](https://auth0.com/docs/get-started/mcp/getting-started-with-model-context-protocol-mcp).

<AmpContent>
<amp-youtube
    data-videoid="-Oq022WDIuY"
    layout="responsive"
    width="480" height="270">
</amp-youtube>
</AmpContent>
<NonAmpContent>
<div class='embed-container' style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%;margin-bottom:40px;"><iframe style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" src='https://www.youtube.com/embed/-Oq022WDIuY' frameborder='0' allowfullscreen></iframe></div>
</NonAmpContent>


We want to make it easier for you to secure your apps with Auth0. Maybe you use an AI tool to help test your code, write documentation, or just “vibe code” your way through a new proof-of-concept app. Imagine saying to your favorite AI tool:

> “I want to create a mobile app with passkey and Google Sign-In, and access to an API with these scopes…”

and having Auth0 set up everything for you automatically.

Well, now you can.

We’re excited to introduce the **Auth0 MCP Server**, which enables AI tools like Claude Desktop, Cursor, Windsurf and other [MCP Clients](https://modelcontextprotocol.io/clients) to securely configure your Auth0 tenant using natural language through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction).

With the Auth0 MCP Server, you can delegate tasks like creating applications, configuring APIs, or deploying Auth0 Actions without exposing credentials and without interrupting your flow to interact with the Auth0 Dashboard.

MCP is just the bridge, what really matters is how effortlessly you can now configure Auth0.

If you want to understand more about MCP in general and how auth plays a role in the world of MCP read the following guide:

<include src="LinkCard" 
    link="https://auth0.com/blog/an-introduction-to-mcp-and-authorization/"
    title="An Introduction to MCP and Authorization"
    description="Discover the Model Context Protocol (MCP) and its authorization mechanisms. Learn how to use API keys, OAuth 2.1 implementation, and best practices for secure LLM API connections." 
    img="https://images.ctfassets.net/23aumh6u8s0i/ImPbKVGMqKM4FMs9Flncw/f715edcaec63105c95189125436cc3a1/MCP_and_Authorization.jpg" />

## What Is the Auth0 MCP Server?

**MCP** is an open protocol that standardizes how AI applications talk and pass context along to an LLM. With the Auth0 MCP Server, you can use commands like the one below in the supported AI client of your preference:

> “Create a new Auth0 application named staging-app with a callback URL of https://staging.example.com/callback.”

The Auth0 MCP Server will receive the request in the MCP format and turn them into actual Auth0 Management API calls while enforcing secure authentication, scoping, and permissions through OAuth 2.0.

![High level diagram showing how the Auth0 MCP Server](https://images.ctfassets.net/23aumh6u8s0i/5pwkaCQFO7xNuQUnKQNdue/6418d6e3446c0d779ce9304ccb3b0f6a/Uploaded_from_Auth0_MCP_Server_Announcement)

This means you can delegate identity management operations to your favourite supported AI tool without handing over raw API tokens or direct access to the Auth0 Management API.

## What You Can Do with Auth0 MCP Server

With the Auth0 MCP Server, your AI tool can:

*   **List and manage Auth0 applications** – List, create, update or Applications (Web Apps, Native, and SPAs)
*   **Access and configure APIs (Resource Servers)** – Create, update or APIs
*   **Inspect tenant-level Auth0 Actions** – List, update, or deploy Auth0 Actions in a tenant
*   **Interact with Tenant Logs** – Get and search logs
*   **Manage Forms** – List, create, update, or Auth0 Forms

These capabilities mean that Claude Desktop, Cursor, and others can become your personal Auth0-assistant, setting up configurations so that you can secure applications with Auth0 even faster. Imagine building your application in Cursor while telling Cursor to create the corresponding Auth0 Application with the necessary Callback URL and Logout URLs configuration in a single message.

### Auth0 MCP Server Key Features

##### Secure Authentication

Uses Device Authorization Flow to give all supported AI tools scoped-access to your Auth0 account. This allows you to manage applications, APIs, Auth0 Actions, and more by prompting your AI tool to do so.

##### Protected Credentials

Stores credentials securely in the system keychain, preventing unauthorized access. Only the Auth0 MCP Server has access to the Auth0 access token and refresh token stored.

##### Comprehensive Tools

Supports a collection of operations for your Auth0 tenant management. CRUD operations for your APIs and applications protected with Auth0 through the Management API, deployment of tenant-level Auth0 Actions, and more. See the [complete list of operations available here](https://auth0.com/docs/get-started/mcp/model-context-protocol-mcp-tools-reference).

##### Seamless Integration

Follows the standard Model Context Protocol and allows you to work directly with [any supported MCP Client](https://modelcontextprotocol.io/clients). The Auth0 MCP Server setup will take care of making all the configuration for you so you can start prompting right away in Claude Desktop, Cursor, and Windsurf.

## How The Auth0 MCP Server Works

Under the hood, the Auth0 MCP Server serves as a bridge between the MCP JSON schema and the **Auth0 Management API**.

![Device Authorization Flow in the Auth0 MCP Server context](https://images.ctfassets.net/23aumh6u8s0i/5YRh5xZe6m6M4qnrsUjJUY/e56bbab80cb012b3b12b3ec465e6e7b9/Uploaded_from_Auth0_MCP_Server_Announcement)

When you initialize the Auth0 MCP Server you’ll go through the [device authorization flow](https://auth0.com/docs/get-started/authentication-and-authorization-flow/device-authorization-flow): a browser window will open up for you to authenticate to Auth0 and choose your tenant. After authenticating, your credentials will be safely stored in your system’s keychain or equivalent app depending on your operating system. Once configuration is done, you’ll be able to interact with Auth0 through any supported AI tool and all of that without having to copy your API key.

![Auth0 consent screen](https://images.ctfassets.net/23aumh6u8s0i/MA5ybpuZEcPiM3qUprt9i/7ea2cf5bf2902da7a47413cd561c6406/Uploaded_from_Auth0_MCP_Server_Announcement)

No matter which tool you are using, all of them will follow a similar collection of steps as outlined above.

## Getting Started with the Auth0 MCP Server

To get started with the Auth0 MCP Server, follow the steps below.

### Prerequisites

*   [Node.js v18](http://node.js)+
*   [Claude Desktop](https://claude.ai/download), [Cursor](https://www.cursor.com/downloads), or [Windsurf](https://www.windsurf.com/editor/download), or your favorite MCP host.
*   Auth0 account

### Install and Configure

Install and initialize the Auth0 MCP Server with a single command:

```sh
npx @auth0/auth0-mcp-server init
```

Then, you need to restart your tool for the updates to take effect. That’s it.

![Terminal showing the result of running ‘npx @auth0/auth0-mcp-server init’](https://images.ctfassets.net/23aumh6u8s0i/6v898a9HHNxLJw0XN5dVGy/1b6db2a87c7690e169c0b3ebfb8290ee/Uploaded_from_Auth0_MCP_Server_Announcement)

The initialization will:

1.  Start the [device authorization flow](https://auth0.com/docs/get-started/authentication-and-authorization-flow/device-authorization-flow);
2.  Open your browser for you to authenticate with Auth0, select your preferred Auth0 tenant, and confirm permissions on the consent screen;
3.  Store your credentials (Auth0 access token and refresh token) securely in your system's keychain;
4.  Create configurations for Claude Desktop to use the Auth0 MCP Server.

Since the stored credentials are an Auth0 access token and a refresh token, you don’t have to authenticate every time you want to use the MCP Server. The server will take care of getting new access tokens when they expire. Additionally, if you want to change the tenant you are currently using, run the `init` command again, this will allow you to select a different tenant.

The MCP Host you are using e.g.: Claude Desktop, identifies which MCP Server you want to use based on your prompt. The MCP Host will then use the configuration files to interact with that MCP Server. This is what a configuration file for Claude Desktop looks like:

```json
{
  "mcpServers": {
    "auth0": {
      "command": "npx",
      "args": [
        "-y",
        "@auth0/auth0-mcp-server",
        "run"
      ],
      "capabilities": [
        "tools"
      ],
      "env": {
        "DEBUG": "auth0-mcp",
        "PATH": "..."
      }
    }
  }
}
```

For instructions on [how to set up other clients read this documentation](https://auth0.com/docs/get-started/mcp/getting-started-with-model-context-protocol-mcp#other-mcp-clients).

Let’s take a look at what happens when you want to use Cursor with the Auth0 MCP Server to secure a FastAPI web app:

1.  You initialize the Auth0 MCP Server passing Cursor as the client like so:

```sh
npx @auth0/auth0-mcp-server init --client cursor
```

And go through the authentication and selection of your tenant

1.  Then you open Cursor and implement your web app in FastAPI like you normally would and protect it using Auth0
2.  Once implemented, you prompt Cursor to create a new Auth0 application with a prompt similar to this:

    “Create a new Auth0 web app application named ‘My FastAPI App’, with a Callback URL [http://localhost:4040/callback](http://localhost:4040/callback) and an Allowed Logout URL [http://localhost:4040](http://localhost:4040) and make sure it is OIDC compliant and set the JWT to use `alg` RS256”

1.  In the background Cursor identifies the MCP Server you are trying to use then asks you to allow it to run the tool. Cursor shows you the parameters it is going to use, something like this:

```json
{
  "name": "My FastAPI App",
  "app_type": "regular_web",
  "callbacks": [
    "http://localhost:4040/callback"
  ],
  "allowed_logout_urls": [
    "http://localhost:4040"
  ],
  "oidc_conformant": true,
  "jwt_configuration": {
    "alg": "RS256"
  }
}
```

You should double check the parameters, and then you can give your consent for Cursor to run the MCP tool call. It then passes the request in the MCP transport format to the Auth0 MCP Server

1.  The Auth0 MCP Server then maps the request from Cursor to the action in the Auth0 Management API and makes the request using the access tokens stored in the system’s keychain;
2.  Auth0 then checks the credentials and sends back the information to the Auth0 MCP Server which in turn passes the information in the MCP transport to Cursor;
3.  Cursor then takes the received information and transforms it in a natural language answer using the LLM to show the information of your recently created, it even asks if it should add that to your application environment.

You can see all of this happening in the video below:

<include src="Vidyard" id="PJn2DTV7gjXmmf4rcGeGbg" />

This way Cursor never has access to the access tokens and the Auth0 MCP Server is the only one responsible for interacting with the Auth0 Management API.

Now that you’ve seen how it works you can tell that the possibilities are endless: Can you imagine telling your favorite AI IDE to build a mobile application with Auth0 and the application being built for you without you having to do any setup? We plan to cover this and how to leverage the Auth0 MCP Server with AI tools in future blog posts.

## Recap

Most developers today are leveraging AI tools to write and test code even faster.

With the **Auth0 MCP Server** your MCP Hosts can safely, reliably, and intelligently manage your Auth0 configurations using natural language.

Identity management should be integrated in these tools so developers won’t compromise on security and still keep their productivity levels high.

Share feedback, ideas, and use cases below. We are looking forward to seeing what you’ll build and how you’ll use the Auth0 MCP Server.

### Try It Now 👉 [Check out the source code on GitHub](https://github.com/auth0/auth0-mcp-server) and [our Get Started guide](https://auth0.com/docs/get-started/mcp/getting-started-with-model-context-protocol-mcp)

The Auth0 MCP Server is here!

william_johnson

  Will Johnson is a Developer Advocate at Auth0. He loves teaching topics in a digestible way to empower more developers. He writes blog posts, records screencasts, and writes eBooks to help developers. He's also an instructor on <a target='_blank' rel='noopener noreferrer' href='https://egghead.io'><strong><b>egghead.io</b></strong></a>.


Developer Advocate

Will Johnson

Learn how to use Auth0 to secure a remote MCP server built with Cloudflare Workers to access a protected API.

**TL;DR** - Auth0 is collaborating with Cloudflare to make it easier for developers building remote MCP servers to configure authentication and authorization. Remote MCP servers will allow AI applications to access external services securely. This post details how to use Auth0 to secure a remote MCP server built with Cloudflare Workers to access an external service. It uses a sample Todo API as that external service.

## What are MCP Servers?

Developers are using large language models (LLMs) and AI applications to help build and deploy their code. Those applications are great when using data LLMs have already been trained on, but what if they could connect to external services to get even more information? That’s where the [Model Context Protocol (MCP)](https://auth0.com/blog/an-introduction-to-mcp-and-authorization/) comes in. MCP is a protocol that allows LLMs to connect with external tools and APIs in a standardized way. Using MCP, AI applications can connect with external services without knowing how each API works. MCP achieves this by using a client-server model.

* **MCP Client** &mdash; A client maintains the connection to MCP servers from inside of an LLM-based application.
* **MCP Server** &mdash; A server is always running and listening to be called by an MCP Client. 

Remote MCP servers are accessible on the Internet. Users sign in, and grant permissions to MCP clients using authorization flows with which they are already familiar. This opens up new use cases for users who may not want to run a MCP server locally on their machine, but are comfortable interacting with APIs and granting access online.

## Securing a Remote MCP Server with Auth0 and Cloudflare

Auth0 has collaborated with Cloudflare to help developers secure remote MCP servers powered by [Cloudflare Workers](https://developers.cloudflare.com/workers/). With the pace of MCP adoption rapidly increasing, Cloudflare has continued to keep up with innovation - [adding features to its platform](https://blog.cloudflare.com/remote-model-context-protocol-servers-mcp/) that handle the hard parts of building remote MCP servers, like `workers-oauth-provider`, an OAuth Provider that makes authorization easy. By [securing your MCP server with Auth0](https://auth0.com/blog/an-introduction-to-mcp-and-authorization/), AI applications can now interact with an external API by connecting through the remote MCP server and make API calls on behalf of an authenticated user.

In the rest of this blog post, we will walkthrough a practical example of this. We will set up and use an AI application to connect with a sample Todos API using an MCP server secured by Auth0. The server and API are Cloudflare Workers projects and will use Auth0 to request and receive access and refresh tokens.

![Diagram of request from MCP Client to a Todo API using Auth0 and Cloudflare](https://images.ctfassets.net/23aumh6u8s0i/1ycXxkqfevcl9XgqrtAL7E/b69b63cd6936a09343f7664229e07919/mcp-8.png)

We will first create the necessary accounts and set up the Todos API, then deploy and configure an MCP server that will connect to Auth0, and finally, the MCP Client can request information from the Todos API.

## Get Started

To follow along, you will want to set up your local developer environment. To get started:

* Create an [Auth0 Account](https://auth0.com/signup?place=header&type=button&text=sign%20up).
* Create a [Cloudflare Account](https://www.cloudflare.com/).
* Install Visual Studio Code (or your favorite code editor).

Once you create those accounts, you will want to 

* Install [Node.js](https://nodejs.org/en/download) (v18+).
* Install [Git](https://git-scm.com/downloads).
* Install the Cloudflare Wrangler CLI. [Read the documentation on installing Wrangler here](https://developers.cloudflare.com/workers/wrangler/install-and-update/).

### Get the Todo API and Remote Auth0 MCP server sample applications

The sample Todos API and remote MCP server are within the [Cloudflare AI monorepo](https://github.com/cloudflare/ai). Clone the repo, navigate to each application, and install the dependencies using the following commands in the terminal.

For the **Todos API**:

```
git clone https://github.com/cloudflare/ai.git
cd ai/demos/remote-mcp-auth0/todos-api
npm install
```

The TodosAPI is built with the [Hono web framework](https://hono.dev/),

For the **remote MCP** Server:

```
cd ../mcp-auth0-oidc
npm install
```

With both of the projects available locally and dependencies installed, proceed to the next step to secure the Todos API with Auth0.

### Configure the Todos API with Auth0

Let’s configure the Todos API to be secured by Auth0. Doing this will allow the remote MCP server to receive both access and refresh tokens and perform actions on behalf of the end user. To get started, [login to your Auth0 account](https://auth0.com/api/auth/login?redirectTo=dashboard) to visit the Auth0 Dashboard.

Create an API on the Auth0 Dashboard by going to [Applications > APIs](https://manage.auth0.com/#/apis/). Then click **Create API**.

![Create API modal in Auth0 Dashboard](https://images.ctfassets.net/23aumh6u8s0i/klUW8q2EKjmE0CnTpaTU6/bb20af2cc6123644879ec38f09c51c73/Screenshot_2025-04-10_at_3.27.31_PM.png)

Next, enter the following values in the following fields:

* In the **Name** field, enter “Todos API”.
* In the** Identifier** field, enter `urn:todos-api`. This value will be used as the audience parameter when the MCP server makes an authorization call to the Todos API.
* Press the **Create** button

The next step is to allow a refresh token to be retrieved when requested by the remote MCP server. Go to [Applications > APIs](https://manage.auth0.com/#/apis/) and click on the entry for the Todos API. Visit **Settings**, scroll down to **Access Settings**, and toggle the **Allow Offline Access** button to enable it. Then click **Save**.

![Screenshot of API Access Settings in Auth0 Dashboard](https://images.ctfassets.net/23aumh6u8s0i/6qoFrMXPUzyt5Z6SWK9o9w/517bf73eac7a9f701c984d18aec18fdf/Screenshot_2025-04-10_at_3.33.40_PM.png)

Toggling on the Allow Offline Access, allows a [refresh token](https://auth0.com/docs/secure/tokens/refresh-tokens) to be retrieved by the MCP server, so the user doesn’t have to keep re-authenticating when an access token expires.

As a final step - the permissions (scopes) need to be configured in the Auth0 Dashboard. These will be granted when a user authorizes an application to gain access to an API. In the API settings for the Todos API, go to the **Permissions** tab and add `read:todos` and `read:billing` as permissions, add a description, and press the **+ Add** button to effectively create the permissions.

![Screenshot of API Permissions tab on Auth0 Dashboard](https://images.ctfassets.net/23aumh6u8s0i/4KSfabe2W5eQh5TuOF2cts/3ddf1ea4fd1eceadbff80d31ad5eed6c/Screenshot_2025-04-10_at_3.37.04_PM.png)

With the permissions in place, the Todos API is created and configured within Auth0. You need to give the Todos API the information from Auth0.

Open the Todos API project in your preferred code editor, set configuration values to connect it to the API you just created in the Auth0 Dashboard, and then deploy it via the Wrangler CLI.

In the root of the Todos API project, create a `.dev.vars` file. With the following format:

```
AUTH0_DOMAIN=
AUTH0_AUDIENCE=urn:todos-api
```

Note that you already have the `AUTH0_AUDIENCE` from when you created your API. Now, you’ll need to fill in the Auth0 Domain.

Whenever a new API is created in the Auth0 Dashboard, you also get a test application that allows you to get access tokens and make requests to your protected API. You can see the test application under [Applications>Applications](https://manage.auth0.com/#/applications).

Now that you are in the Applications section of the Dashboard click on the “*Todos API (Test Application)*”, which will load the settings and copy the **Domain** value. The domain will be used in the next step when we update the Todos API project. 

![Screenshot of Todo API application settings in the Auth0 Dashboard](https://images.ctfassets.net/23aumh6u8s0i/1tYPzi9JnFGx0UfzIIU2p9/ea37c64f67666bc254ea05e6aef3d352/Screenshot_2025-04-07_at_1.03.54_PM.png)

Update your `.dev.vars` file to contain the Domain like so:

```
AUTH0_DOMAIN=Your Auth0 domain (e.g., acme.auth0.com)
AUTH0_AUDIENCE=urn:todos-api
```

### Testing the Todos API

With the Todos API configured both in Auth0 and locally, you can make requests to it.

Run the Todos API with the following command:

```
npm run dev
```

This will start the worker and allow you to make requests to the Todos API. 

To get the `access_token` to call the API, on the Auth0 Dashboard go to **Applications > APIs, **click on the** Todos API **then select the **Test** tab. This will give you the cURL command to request the access token.

![Screenshot of Todos API Test Tab](https://images.ctfassets.net/23aumh6u8s0i/3aXJxxBRZP75mib0aGAJyS/22204edc710ede9ae7c7b4a706dbe2d8/Screenshot_2025-04-09_at_1.52.22_PM.png)

In your terminal, run the command from the **Test** tab, and be sure to use the `client_id` and `client_secret` values from Auth0.

```
curl --request POST \
  --url https://dev-aggvwbxi.us.auth0.com/oauth/token \
  --header 'content-type: application/json' \
  --data '{"client_id":".....","client_secret":".....","audience":"urn:todos-api","grant_type":"client_credentials"}'
```

The cURL command will show the response with the access token like below:

```
{
  "access_token": ".......",
  "token_type": "Bearer"
}
```

Next, make a request to the API passing the access token in the Authorization header.

```
curl --request GET \
  --url http://localhost:8788/api/me \
  --header 'Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6Im...'
```

On a successful call, you will see the claims of the JWT token in the response.

## Deploy the Todos API to Cloudflare

The Todos API is a Cloudflare Workers project, which means it can process Wrangler commands. With everything you have in place so far, you can use Wrangler to set secrets locally and deploy the API to Cloudflare. Using the terminal, navigate to your project folder and run the following commands:

```
wrangler secret put AUTH0_DOMAIN
wrangler secret put AUTH0_AUDIENCE
```

Now that the secrets are set, you can deploy the Todos API to Cloudflare with the following command:

```
wrangler deploy
```

Now that the Todos API is deployed to Cloudflare and secured by Auth0. Keep the project open as we’ll use the terminal in the next step to configure and deploy the remote MCP server.

## Configure and Deploy the Remote MCP Server

In this step, we will configure the remote MCP server secured with Auth0 and make requests to the Todos API. This includes creating an application for it in the Auth0 Dashboard and deploying it to Cloudflare.

Head back to the Auth0 Dashboard and create a web application by going to [Applications → Applications](https://manage.auth0.com/#/applications). Click **Create Application** and enter the following values:

* For the **Name** field, enter “Remote MCP Server”
* Choose **Regular Web Applications** as the Application Type
* Click the **Create** button

![Create Application Modal in Auth0 Dashboard](https://images.ctfassets.net/23aumh6u8s0i/3HJs03fVbMD1dRZzGpcLGh/efa94e5434af3d0bc12dfd7565eae4fd/Screenshot_2025-04-07_at_1.53.58_PM.png)

Next, we will configure the callback URL, which is the URL to which the application will be redirected back to the caller after the user authenticates. To set this, head to the MCP Server application Settings, scroll to **Allowed Callback URLs** in the **Application URIs** section and add the following URL.

```
http://localhost:8788/callback
```

> *Note:* This URL will change when you deploy it to production. 

![Application URIs in application settings on Auth0 Dashboard](https://images.ctfassets.net/23aumh6u8s0i/3VygdrL3LQBItkNhTVy7v7/fc558fd1a2492454302948c7c3d584e0/Screenshot_2025-04-10_at_4.10.52_PM.png)

Next up is creating a [Cloudflare Workers KV](https://developers.cloudflare.com/kv/) namespace. This namespace is used by the remote MCP server and `workers-oauth-provider` to handle authorization requests.

To create a **KV namespace** with Wrangler, in the terminal, run the following command:

```
wrangler kv namespace create "OAUTH_KV"
```

Open the Remote MCP Server project in your code editor and paste the resulting values in the existing `wrangler.jsonc` file using the format below:

```js
//wrangler.jsonc

{
  "kv_namespaces": [
    {
      "binding": "OAUTH_KV",
      "id": "<BINDING_ID>"
    }
  ]
}
```

Now that the KV namespace has been created, the next step is to update configuration values for Wrangler to deploy the remote MCP server to Cloudflare. To configure the application you’ll need a few values from your application settings in the Auth0 Dashboard. 

Go to [Applications → Applications](https://manage.auth0.com/#/applications), then click on the Remote MCP Server application. There, you can take note of your Auth0 Domain, Client ID, and Client Secret. 

![Auth0 application settings](https://images.ctfassets.net/23aumh6u8s0i/3HJs03fVbMD1dRZzGpcLGh/efa94e5434af3d0bc12dfd7565eae4fd/Screenshot_2025-04-07_at_1.53.58_PM.png)

With the project open in your preferred code editor, create a .dev.vars in the root of the project and add the following values:


```
AUTH0_DOMAIN=Your Auth0 domain (e.g., acme.auth0.com)
AUTH0_CLIENT_ID=The Client ID of the application created in Auth0
AUTH0_CLIENT_SECRET=The Client Secret of the application created in Auth0
AUTH0_AUDIENCE=urn:todos-api
AUTH0_SCOPE=openid email profile offline_access read:todos
NODE_ENV=development
API_BASE_URL=http://localhost:8789
```

### Deploy the MCP Server to Cloudflare

To deploy the remote MCP server to Cloudflare, you first need to set the secrets in Wrangler. To do this, run the following commands:

```
wrangler secret put AUTH0_DOMAIN
wrangler secret put AUTH0_CLIENT_ID
wrangler secret put AUTH0_CLIENT_SECRET
wrangler secret put AUTH0_AUDIENCE
wrangler secret put AUTH0_SCOPE
wrangler secret put API_BASE_URL
```

Once the secrets are set, run the following commands to deploy the MCP Server to Cloudflare.

```
wrangler deploy
```

With the MCP server deployed, we can update the **Allowed Callback URLs** in the Application settings within the Auth0 Dashboard using the deployed MCP server URL using this URL pattern.

To change the Allowed Callback URLs, on the Auth0 Dashboard go to **Applications > Applications**, click on **Settings**, scroll down to **Application URIs** and then add the following URL.

```
https://mcp-auth0-oidc.<your-subdomain>.workers.dev/callback
```

![Auth0 Application URI settings](https://images.ctfassets.net/23aumh6u8s0i/69X5vC9Cna1nKKvicpWTp6/79de976d5939062bc416d46037c550f6/app-urls-callback.png)

This will make sure that after the user authenticates, they will redirect back to the remote MCP server to make calls to the Todos API. With these steps in place, it’s now time to see the remote MCP server in action.

### Test the Remote MCP Server Call

To test making calls to the Todos API, use the Workers AI LLM Playground. Navigate to [Cloudflare’s AI Playground](https://playground.ai.cloudflare.com/) and connect to the Remote MCP Server URL:

```
https://mcp-auth0-oidc.<your-subdomain>.workers.dev/sse
```

Place the URL in the section labeled MCP Servers and click **Connect**.

![Cloudflare AI workers playground](https://images.ctfassets.net/23aumh6u8s0i/1Jwt30QY8vuTTO3ZMNTZXr/5757f0dc6a99600d8ab404eca3f97061/Screenshot_2025-04-10_at_12.33.42_PM.png)

Then you’ll go through the authorization flow; you need to allow access:

![MCP server access request](https://images.ctfassets.net/23aumh6u8s0i/57yVFkdC5sEhBIXEICo9jo/00327fda1167ae4b61f6d64582f78934/auth-request.png)

This will open the browser, have the user authenticate with Auth0, and allow the remote MCP server to access the resources of the Todos API. 

![Auth0 universal login](https://images.ctfassets.net/23aumh6u8s0i/MJX7hQveJh6BYaMKmIHDn/3ef06aa1a2a047c649278d9a0ee37de9/auth-ul.png)

Once permission is given, you can use the LLM to make requests to the MCP server to get information from the Todos API.

![cloudflare AI playground](https://images.ctfassets.net/23aumh6u8s0i/1sO7ZqO9aF7o0VzYEex9VZ/2aa6f63cf1bd01862dde09a0efdfe221/playground.png)

The Todos API allows requests for todos and billing information. Note that the billing information request will fail to show that the LLM can only make requests for information that it has permissions for.

## Configuring a Remote MCP Server in Claude

Now that you understand how to secure a remote MCP server with Auth0 and know how to deploy it to Cloudflare, it might be good to see how to set it up to your favourite MCP Host. Let’s set up your server in Claude Desktop.

Open Claude Desktop, navigate to the Settings then click on Developer and Edit Config. This will show you Claude’s folder on your computer and the file named `claude_desktop_config.json`.

![Claude Desktop Config JSON file](https://images.ctfassets.net/23aumh6u8s0i/4JAy6wjNRtCEVaLIUSJxDv/ebab95cd543009cac72cf1a22fb90e1e/claude-desktop-config-in-folder.png)

Open that file in your favorite editor, and add the following:

```json
{
  "mcpServers": {
    "math": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp-auth0-oidc.<your-subdomain>.workers.dev/sse"
      ]
    }
  }
}
```

Remember to update the URL to use your Remote MCP Server URL in the arguments list. This configuration names a “`math`” server that runs with `npx` as command and passes the package `mcp-remote` and the URL as parameters to `npx`.

[The `mcp-remote` package](https://www.npmjs.com/package/mcp-remote) is responsible for connecting an MCP Host with `stdio` like Claude Desktop and Cursor to securely access a Remote MCP Server like the one you just deployed.

Once you save the configuration and restart Claude, you’ll be able to prompt Claude about your list of todos:

![Claude using the Remote MCP Server to show the todos list](https://images.ctfassets.net/23aumh6u8s0i/7HE3fATATP2E1Mxr69V11J/84d1c2267567d095f4b9b5cf5a1bbadb/claude-todos-list-mcp-server-and-api.png)

## Conclusion

In this post we walked through the steps needed to secure a MCP Server with Auth0, and connect it to a third party API. You also learned how to deploy your MCP Server to Cloudflare. The MCP server uses Auth0 as a third party identity provider and allows AI tools to call the protected API on behalf of the user.

Remote MCP Servers offer tools that can make LLMs more convenient and give faster access to the information that matters to users. If you are building with GenAI you should check out our brand new product [Auth for GenAI](http://a0.to/ai-content), to enable AI agents to securely access tools, workflows, and data with fine-grained control and just a few lines of code.

You can take a look at the code that was used in these demos [on GitHub](https://github.com/cloudflare/ai/tree/main/demos/remote-mcp-auth0) to try it out for yourself.


---

_This blog may contain hyperlinks to non-Okta websites that are created and maintained by third parties who are solely responsible for the content on such websites._


"auth0 mcp server"