URL: https://gofastmcp.com/integrations/openai
Title: OpenAI API 🤝 FastMCP - FastMCP

Documentation Index
Fetch the complete documentation index at:
/llms.txt
Use this file to discover all available pages before exploring further.
Skip to main content
Meet
Prefect Horizon
, the enterprise MCP gateway built by the team behind FastMCP
FastMCP
home page
v3
Prefect Horizon
PrefectHQ/fastmcp
PrefectHQ/fastmcp
Search...
Navigation
AI SDKs
OpenAI API 🤝 FastMCP
Search the docs...
⌘
K
Documentation
Get Started
Welcome!
Installation
Quickstart
Servers
Overview
Core Components
Working with Tools
MCP Providers
Interactivity
Extensibility
Auth
Deployment
Apps
Overview
Quickstart
NEW
FastMCPApp
NEW
Interactive Tools
NEW
Generative UI
NEW
Custom HTML
Reference
Clients
Overview
Client-Only Package
Transports
fastmcp-remote
Operations
UPDATED
Authentication
UPDATED
Integrations
Auth
Web Frameworks
AI Assistants
AI SDKs
Anthropic API
Gemini SDK
OpenAI API
Pydantic AI
MCP.json
More
Settings
CLI
Upgrading
Development
What's New
FAQ
On this page
Responses API
Create a Server
Deploy the Server
Call the Server
Authentication
Server Authentication
Client Authentication
AI SDKs
OpenAI API 🤝 FastMCP
Copy page
Connect FastMCP servers to the OpenAI API
Copy page
​
Responses API
OpenAI’s
Responses API
supports
MCP servers
as remote tool sources, allowing you to extend AI capabilities with custom functions.
The Responses API is a distinct API from OpenAI’s Completions API or Assistants API. At this time, only the Responses API supports MCP.
Currently, the Responses API only accesses
tools
from MCP servers—it queries the
list_tools
endpoint and exposes those functions to the AI agent. Other MCP features like resources and prompts are not currently supported.
​
Create a Server
First, create a FastMCP server with the tools you want to expose. For this example, we’ll create a server with a single tool that rolls dice.
server.py
import
random
from
fastmcp
import
FastMCP
mcp
=
FastMCP
(
name
=
"
Dice Roller
"
)
@
mcp
.
tool
def
roll_dice
(
n_dice
:
int
)
->
list
[
int
]:
"""
Roll `n_dice` 6-sided dice and return the results.
"""
return
[
random
.
randint
(
1
,
6
)
for
_
in
range
(
n_dice
)]
if
__name__
==
"
__main__
"
:
mcp
.
run
(
transport
=
"
http
"
,
port
=
8000
)
​
Deploy the Server
Your server must be deployed to a public URL in order for OpenAI to access it.
For development, you can use tools like
ngrok
to temporarily expose a locally-running server to the internet. We’ll do that for this example (you may need to install
ngrok
and create a free account), but you can use any other method to deploy your server.
Assuming you saved the above code as
server.py
, you can run the following two commands in two separate terminals to deploy your server and expose it to the internet:
FastMCP server
ngrok
python
server.py
This exposes your unauthenticated server to the internet. Only run this command in a safe environment if you understand the risks.
​
Call the Server
To use the Responses API, you’ll need to install the OpenAI Python SDK (not included with FastMCP):
pip
install
openai
You’ll also need to authenticate with OpenAI. You can do this by setting the
OPENAI_API_KEY
environment variable. Consult the OpenAI SDK documentation for more information.
export
OPENAI_API_KEY
=
"
your-api-key
"
Here is an example of how to call your server from Python. Note that you’ll need to replace
https://your-server-url.com
with the actual URL of your server. In addition, we use
/mcp/
as the endpoint because we deployed a streamable-HTTP server with the default path; you may need to use a different endpoint if you customized your server’s deployment.
from
openai
import
OpenAI
# Your server URL (replace with your actual URL)
url
=
'
https://your-server-url.com
'
client
=
OpenAI
()
resp
=
client
.
responses
.
create
(
model
=
"
gpt-4.1
"
,
tools
=[
{
"
type
"
:
"
mcp
"
,
"
server_label
"
:
"
dice_server
"
,
"
server_url
"
:
f
"
{
url
}
/mcp/"
,
"
require_approval
"
:
"
never
"
,
},
],
input
=
"
Roll a few dice!
"
,
)
print
(
resp
.
output_text
)
If you run this code, you’ll see something like the following output:
You rolled 3 dice and got the following results: 6, 4, and 2!
​
Authentication
The Responses API can include headers to authenticate the request, which means you don’t have to worry about your server being publicly accessible.
​
Server Authentication
The simplest way to add authentication to the server is to use a bearer token scheme.
For this example, we’ll quickly generate our own tokens with FastMCP’s
RSAKeyPair
utility, but this may not be appropriate for production use. For more details, see the complete server-side
Token Verification
documentation.
We’ll start by creating an RSA key pair to sign and verify tokens.
from
fastmcp
.
server
.
auth
.
providers
.
jwt
import
RSAKeyPair
key_pair
=
RSAKeyPair
.
generate
()
access_token
=
key_pair
.
create_token
(
audience
=
"
dice-server
"
)
FastMCP’s
RSAKeyPair
utility is for development and testing only.
Next, we’ll create a
JWTVerifier
to authenticate the server.
from
fastmcp
import
FastMCP
from
fastmcp
.
server
.
auth
import
JWTVerifier
auth
=
JWTVerifier
(
public_key
=
key_pair
.
public_key
,
audience
=
"
dice-server
"
,
)
mcp
=
FastMCP
(
name
=
"
Dice Roller
"
,
auth
=
auth
)
Here is a complete example that you can copy/paste. For simplicity and the purposes of this example only, it will print the token to the console.
Do NOT do this in production!
server.py
from
fastmcp
import
FastMCP
from
fastmcp
.
server
.
auth
import
JWTVerifier
from
fastmcp
.
server
.
auth
.
providers
.
jwt
import
RSAKeyPair
import
random
key_pair
=
RSAKeyPair
.
generate
()
access_token
=
key_pair
.
create_token
(
audience
=
"
dice-server
"
)
auth
=
JWTVerifier
(
public_key
=
key_pair
.
public_key
,
audience
=
"
dice-server
"
,
)
mcp
=
FastMCP
(
name
=
"
Dice Roller
"
,
auth
=
auth
)
@
mcp
.
tool
def
roll_dice
(
n_dice
:
int
)
->
list
[
int
]:
"""
Roll `n_dice` 6-sided dice and return the results.
"""
return
[
random
.
randint
(
1
,
6
)
for
_
in
range
(
n_dice
)]
if
__name__
==
"
__main__
"
:
print
(
f
"
\n
---
\n\n
🔑 Dice Roller access token:
\n\n
{
access_token
}
\n\n
---
\n
"
)
mcp
.
run
(
transport
=
"
http
"
,
port
=
8000
)
See all 23 lines
​
Client Authentication
If you try to call the authenticated server with the same OpenAI code we wrote earlier, you’ll get an error like this:
APIStatusError: Error code: 424 - {
"error": {
"message": "Error retrieving tool list from MCP server: 'dice_server'. Http status code: 401 (Unauthorized)",
"type": "external_connector_error",
"param": "tools",
"code": "http_error"
}
}
As expected, the server is rejecting the request because it’s not authenticated.
To authenticate the client, you can pass the token in the
Authorization
header with the
Bearer
scheme:
from
openai
import
OpenAI
# Your server URL (replace with your actual URL)
url
=
'
https://your-server-url.com
'
# Your access token (replace with your actual token)
access_token
=
'
your-access-token
'
client
=
OpenAI
()
resp
=
client
.
responses
.
create
(
model
=
"
gpt-4.1
"
,
tools
=[
{
"
type
"
:
"
mcp
"
,
"
server_label
"
:
"
dice_server
"
,
"
server_url
"
:
f
"
{
url
}
/mcp/"
,
"
require_approval
"
:
"
never
"
,
"
headers
"
:
{
"
Authorization
"
:
f
"Bearer
{
access_token
}
"
}
},
],
input
=
"
Roll a few dice!
"
,
)
print
(
resp
.
output_text
)
See all 27 lines
You should now see the dice roll results in the output.
Gemini SDK 🤝 FastMCP
Previous
Pydantic AI 🤝 FastMCP
Next
⌘
I
discord
github
website
x
Powered by
This documentation is built and hosted on Mintlify, a developer documentation platform
Assistant
Responses are generated using AI and may contain mistakes.
