184 </div>184 </div>

185 <div data-content-switcher-pane data-value="file-url" hidden>185 <div data-content-switcher-pane data-value="file-url" hidden>

186 <div class="hidden">File URL</div>186 <div class="hidden">File URL</div>

187 Use a file URL as input

188 

189```bash

190curl "https://api.openai.com/v1/responses" \\

191 -H "Content-Type: application/json" \\

192 -H "Authorization: Bearer $OPENAI_API_KEY" \\

193 -d '{

194 "model": "gpt-5",

195 "input": [

196 {

197 "role": "user",

198 "content": [

199 {

200 "type": "input_text",

201 "text": "Analyze the letter and provide a summary of the key points."

202 },

203 {

204 "type": "input_file",

205 "file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf"

206 }

207 ]

208 }

209 ]

210 }'

211```

212 

213```javascript

214import OpenAI from "openai";

215const client = new OpenAI();

216 

217const response = await client.responses.create({

218 model: "gpt-5",

219 input: [

220 {

221 role: "user",

222 content: [

223 {

224 type: "input_text",

225 text: "Analyze the letter and provide a summary of the key points.",

226 },

227 {

228 type: "input_file",

229 file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf",

230 },

231 ],

232 },

233 ],

234});

235 

236console.log(response.output_text);

237```

238 

239```python

240from openai import OpenAI

241client = OpenAI()

242 

243response = client.responses.create(

244 model="gpt-5",

245 input=[

246 {

247 "role": "user",

248 "content": [

249 {

250 "type": "input_text",

251 "text": "Analyze the letter and provide a summary of the key points.",

252 },

253 {

254 "type": "input_file",

255 "file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf",

256 },

257 ],

258 },

259 ]

260)

261 

262print(response.output_text)

263```

264 

265```csharp

266using OpenAI.Files;

267using OpenAI.Responses;

268 

269string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

270OpenAIResponseClient client = new(model: "gpt-5", apiKey: key);

271 

272using HttpClient http = new();

273using Stream stream = await http.GetStreamAsync("https://www.berkshirehathaway.com/letters/2024ltr.pdf");

274OpenAIFileClient files = new(key);

275OpenAIFile file = files.UploadFile(stream, "2024ltr.pdf", FileUploadPurpose.UserData);

276 

277OpenAIResponse response = (OpenAIResponse)client.CreateResponse([

278 ResponseItem.CreateUserMessageItem([

279 ResponseContentPart.CreateInputTextPart("Analyze the letter and provide a summary of the key points."),

280 ResponseContentPart.CreateInputFilePart(file.Id),

281 ]),

282]);

283 

284Console.WriteLine(response.GetOutputText());

285```

286 

287 </div>187 </div>

288 <div data-content-switcher-pane data-value="file-upload" hidden>188 <div data-content-switcher-pane data-value="file-upload" hidden>

289 <div class="hidden">Upload file</div>189 <div class="hidden">Upload file</div>

290 Upload a file and use it as input

291 

292```bash

293curl https://api.openai.com/v1/files \\

294 -H "Authorization: Bearer $OPENAI_API_KEY" \\

295 -F purpose="user_data" \\

296 -F file="@draconomicon.pdf"

297 

298curl "https://api.openai.com/v1/responses" \\

299 -H "Content-Type: application/json" \\

300 -H "Authorization: Bearer $OPENAI_API_KEY" \\

301 -d '{

302 "model": "gpt-5",

303 "input": [

304 {

305 "role": "user",

306 "content": [

307 {

308 "type": "input_file",

309 "file_id": "file-6F2ksmvXxt4VdoqmHRw6kL"

310 },

311 {

312 "type": "input_text",

313 "text": "What is the first dragon in the book?"

314 }

315 ]

316 }

317 ]

318 }'

319```

320 

321```javascript

322import fs from "fs";

323import OpenAI from "openai";

324const client = new OpenAI();

325 

326const file = await client.files.create({

327 file: fs.createReadStream("draconomicon.pdf"),

328 purpose: "user_data",

329});

330 

331const response = await client.responses.create({

332 model: "gpt-5",

333 input: [

334 {

335 role: "user",

336 content: [

337 {

338 type: "input_file",

339 file_id: file.id,

340 },

341 {

342 type: "input_text",

343 text: "What is the first dragon in the book?",

344 },

345 ],

346 },

347 ],

348});

349 

350console.log(response.output_text);

351```

352 

353```python

354from openai import OpenAI

355client = OpenAI()

356 

357file = client.files.create(

358 file=open("draconomicon.pdf", "rb"),

359 purpose="user_data"

360)

361 

362response = client.responses.create(

363 model="gpt-5",

364 input=[

365 {

366 "role": "user",

367 "content": [

368 {

369 "type": "input_file",

370 "file_id": file.id,

371 },

372 {

373 "type": "input_text",

374 "text": "What is the first dragon in the book?",

375 },

376 ]

377 }

378 ]

379)

380 

381print(response.output_text)

382```

383 

384```csharp

385using OpenAI.Files;

386using OpenAI.Responses;

387 

388string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

389OpenAIResponseClient client = new(model: "gpt-5", apiKey: key);

390 

391OpenAIFileClient files = new(key);

392OpenAIFile file = files.UploadFile("draconomicon.pdf", FileUploadPurpose.UserData);

393 

394OpenAIResponse response = (OpenAIResponse)client.CreateResponse([

395 ResponseItem.CreateUserMessageItem([

396 ResponseContentPart.CreateInputFilePart(file.Id),

397 ResponseContentPart.CreateInputTextPart("What is the first dragon in the book?"),

398 ]),

399]);

400 

401Console.WriteLine(response.GetOutputText());

402```

403 

404 </div>190 </div>

405 191 

406 192 

432 </div>218 </div>

433 <div data-content-switcher-pane data-value="file-search" hidden>219 <div data-content-switcher-pane data-value="file-search" hidden>

434 <div class="hidden">File search</div>220 <div class="hidden">File search</div>

435 Search your files in a response

436 

437```python

438from openai import OpenAI

439client = OpenAI()

440 

441response = client.responses.create(

442 model="gpt-4.1",

443 input="What is deep research by OpenAI?",

444 tools=[{

445 "type": "file_search",

446 "vector_store_ids": ["<vector_store_id>"]

447 }]

448)

449print(response)

450```

451 

452```javascript

453import OpenAI from "openai";

454const openai = new OpenAI();

455 

456const response = await openai.responses.create({

457 model: "gpt-4.1",

458 input: "What is deep research by OpenAI?",

459 tools: [

460 {

461 type: "file_search",

462 vector_store_ids: ["<vector_store_id>"],

463 },

464 ],

465});

466console.log(response);

467```

468 

469```csharp

470using OpenAI.Responses;

471 

472string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

473OpenAIResponseClient client = new(model: "gpt-5", apiKey: key);

474 

475ResponseCreationOptions options = new();

476options.Tools.Add(ResponseTool.CreateFileSearchTool(["<vector_store_id>"]));

477 

478OpenAIResponse response = (OpenAIResponse)client.CreateResponse([

479 ResponseItem.CreateUserMessageItem([

480 ResponseContentPart.CreateInputTextPart("What is deep research by OpenAI?"),

481 ]),

482], options);

483 

484Console.WriteLine(response.GetOutputText());

485```

486 

487 </div>221 </div>

488 <div data-content-switcher-pane data-value="function-calling" hidden>222 <div data-content-switcher-pane data-value="function-calling" hidden>

489 <div class="hidden">Function calling</div>223 <div class="hidden">Function calling</div>

490 </div>224 </div>

491 <div data-content-switcher-pane data-value="remote-mcp" hidden>225 <div data-content-switcher-pane data-value="remote-mcp" hidden>

492 <div class="hidden">Remote MCP</div>226 <div class="hidden">Remote MCP</div>

493 Call a remote MCP server

494 

495```bash

496curl https://api.openai.com/v1/responses \\

497-H "Content-Type: application/json" \\

498-H "Authorization: Bearer $OPENAI_API_KEY" \\

499-d '{

500 "model": "gpt-5",

501 "tools": [

502 {

503 "type": "mcp",

504 "server_label": "dmcp",

505 "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",

506 "server_url": "https://dmcp-server.deno.dev/sse",

507 "require_approval": "never"

508 }

509 ],

510 "input": "Roll 2d4+1"

511 }'

512```

513 

514```javascript

515import OpenAI from "openai";

516const client = new OpenAI();

517 

518const resp = await client.responses.create({

519 model: "gpt-5",

520 tools: [

521 {

522 type: "mcp",

523 server_label: "dmcp",

524 server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",

525 server_url: "https://dmcp-server.deno.dev/sse",

526 require_approval: "never",

527 },

528 ],

529 input: "Roll 2d4+1",

530});

531 

532console.log(resp.output_text);

533```

534 

535```python

536from openai import OpenAI

537 

538client = OpenAI()

539 

540resp = client.responses.create(

541 model="gpt-5",

542 tools=[

543 {

544 "type": "mcp",

545 "server_label": "dmcp",

546 "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",

547 "server_url": "https://dmcp-server.deno.dev/sse",

548 "require_approval": "never",

549 },

550 ],

551 input="Roll 2d4+1",

552)

553 

554print(resp.output_text)

555```

556 

557```csharp

558using OpenAI.Responses;

559 

560string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

561OpenAIResponseClient client = new(model: "gpt-5", apiKey: key);

562 

563ResponseCreationOptions options = new();

564options.Tools.Add(ResponseTool.CreateMcpTool(

565 serverLabel: "dmcp",

566 serverUri: new Uri("https://dmcp-server.deno.dev/sse"),

567 toolCallApprovalPolicy: new McpToolCallApprovalPolicy(GlobalMcpToolCallApprovalPolicy.NeverRequireApproval)

568));

569 

570OpenAIResponse response = (OpenAIResponse)client.CreateResponse([

571 ResponseItem.CreateUserMessageItem([

572 ResponseContentPart.CreateInputTextPart("Roll 2d4+1")

573 ])

574], options);

575 

576Console.WriteLine(response.GetOutputText());

577```

578 

579 </div>227 </div>

580 228 

581 229