How to integrate Gift up MCP with OpenAI Agents SDK

Connect OpenAI Agents SDK to Gift up MCP. List all active gift cards sold this week, show available items for sale by group, and more using natural language, with authentication handled for you.

Gift up logoGift up
Api Key

Gift Up! is a digital platform for selling, managing, and redeeming gift cards online. It streamlines promotions and gift card transactions for businesses and their customers.

44 Tools

Introduction

This guide walks you through connecting Gift up to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Gift up agent that can look up gift cards, redeem and top up balances, void or reactivate cards, manage items and orders, and list promotions through natural language commands.

This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Gift up account through Composio's Gift up MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

For exact tool slugs and parameter tables, see the tool catalog in the Composio docs.

Also integrate Gift up with

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Gift up
  • Configure an AI agent that can use Gift up as a tool
  • Run a live chat session where you can ask the agent to perform Gift up operations

What is OpenAI Agents SDK?

The OpenAI Agents SDK is a lightweight framework for building AI agents that can use tools and maintain conversation state. It provides a simple interface for creating agents with hosted MCP tool support.

Key features include:

  • Hosted MCP Tools: Connect to external services through hosted MCP endpoints
  • SQLite Sessions: Persist conversation history across interactions
  • Simple API: Clean interface with Agent, Runner, and tool configuration
  • Streaming Support: Real-time response streaming for interactive applications

What is the Gift up MCP server, and what's possible with it?

The Gift up MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Gift Up! account. It provides structured and secure access to your gift card operations, so your agent can list available gift cards, fetch company or checkout details, generate transaction reports, and manage users or webhook subscriptions on your behalf.

  • Gift card inventory management: Instantly list, filter, and audit all gift cards issued or available in your account, including status and details.
  • Sales item and group retrieval: Let your agent fetch all items for sale and organize them by item groups, making it easy to manage or present products.
  • Company and checkout settings access: Retrieve current company details and checkout configuration to audit or display your store's gift card setup.
  • Transaction reporting and analytics: Generate and filter transaction reports for deep insights into gift card sales, redemptions, and trends.
  • User and webhook management: List all users with account access or subscribe to webhook events, enabling automated notifications and streamlined team management.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and OpenAI API Key
  • Primary know-how of OpenAI Agents SDK
  • A live Gift up project
  • Some knowledge of Python or Typescript
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
3

Install dependencies

npm install @composio/openai-agents @openai/agents dotenv

Install the Composio SDK and the OpenAI Agents SDK.

4

Set up environment variables

bash
OPENAI_API_KEY=sk-...your-api-key
COMPOSIO_API_KEY=your-api-key
USER_ID=composio_user@gmail.com

Create a .env file and add your OpenAI and Composio API keys.

5

Import dependencies

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';
What's happening:
  • You're importing all necessary libraries.
  • The Composio and OpenAIAgentsProvider classes are imported to connect your OpenAI agent to Composio tools like Gift up.
6

Set up the Composio instance

dotenv.config();

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.USER_ID;

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});
What's happening:
  • dotenv.config() loads your .env file so COMPOSIO_API_KEY and USER_ID are available as environment variables.
  • Creating a Composio instance using the API Key and OpenAIAgentsProvider class.
7

Create a Tool Router session

// Create Tool Router session for Gift up
const session = await composio.create(userId as string, {
  toolkits: ['gift_up'],
});
const mcpUrl = session.mcp.url;

What is happening:

  • You give the Tool Router the user id and the toolkits you want available. Here, it is only gift_up.
  • The router checks the user's Gift up connection and prepares the MCP endpoint.
  • The returned session.mcp.url is the MCP URL that your agent will use to access Gift up.
  • This approach keeps things lightweight and lets the agent request Gift up tools only when needed during the conversation.
8

Configure the agent

// Configure agent with MCP tool
const agent = new Agent({
  name: 'Assistant',
  model: 'gpt-5',
  instructions:
    'You are a helpful assistant that can access Gift up. Help users perform Gift up operations through natural language.',
  tools: [
    hostedMcpTool({
      serverLabel: 'tool_router',
      serverUrl: mcpUrl,
      headers: { 'x-api-key': composioApiKey },
      requireApproval: 'never',
    }),
  ],
});
What's happening:
  • We're creating an Agent instance with a name, model (gpt-5), and clear instructions about its purpose.
  • The agent's instructions tell it that it can access Gift up and help with queries, inserts, updates, authentication, and fetching database information.
  • The tools array includes a hostedMcpTool that connects to the MCP server URL we created earlier.
  • The headers object includes the Composio API key for secure authentication with the MCP server.
  • requireApproval: 'never' means the agent can execute Gift up operations without asking for permission each time, making interactions smoother.
9

Start chat loop and handle conversation

// Keep conversation state across turns
const conversationSession = new OpenAIConversationsSession();

// Simple CLI
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'You: ',
});

console.log('\nComposio Tool Router session created.');
console.log('\nChat started. Type your requests below.');
console.log("Commands: 'exit', 'quit', or 'q' to end\n");

try {
  const first = await run(agent, 'What can you help me with?', { session: conversationSession });
  console.log(`Assistant: ${first.finalOutput}\n`);
} catch (e) {
  console.error('Error:', e instanceof Error ? e.message : e, '\n');
}

rl.prompt();

rl.on('line', async (userInput) => {
  const text = userInput.trim();

  if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
    console.log('Goodbye!');
    rl.close();
    process.exit(0);
  }

  if (!text) {
    rl.prompt();
    return;
  }

  try {
    const result = await run(agent, text, { session: conversationSession });
    console.log(`\nAssistant: ${result.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();
});

rl.on('close', () => {
  console.log('\n👋 Session ended.');
  process.exit(0);
});
What's happening:
  • The program prints a session URL that you visit to authorize Gift up.
  • After authorization, the chat begins.
  • Each message you type is processed by the agent using run().
  • The responses are printed to the console.
  • Typing exit, quit, or q cleanly ends the chat.

Complete Code

Here's the complete code to get you started with Gift up and OpenAI Agents SDK:

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.USER_ID;

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});

async function main() {
  // Create Tool Router session
  const session = await composio.create(userId as string, {
    toolkits: ['gift_up'],
  });
  const mcpUrl = session.mcp.url;

  // Configure agent with MCP tool
  const agent = new Agent({
    name: 'Assistant',
    model: 'gpt-5',
    instructions:
      'You are a helpful assistant that can access Gift up. Help users perform Gift up operations through natural language.',
    tools: [
      hostedMcpTool({
        serverLabel: 'tool_router',
        serverUrl: mcpUrl,
        headers: { 'x-api-key': composioApiKey },
        requireApproval: 'never',
      }),
    ],
  });

  // Keep conversation state across turns
  const conversationSession = new OpenAIConversationsSession();

  // Simple CLI
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: ',
  });

  console.log('\nComposio Tool Router session created.');
  console.log('\nChat started. Type your requests below.');
  console.log("Commands: 'exit', 'quit', or 'q' to end\n");

  try {
    const first = await run(agent, 'What can you help me with?', { session: conversationSession });
    console.log(`Assistant: ${first.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();

  rl.on('line', async (userInput) => {
    const text = userInput.trim();

    if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
      console.log('Goodbye!');
      rl.close();
      process.exit(0);
    }

    if (!text) {
      rl.prompt();
      return;
    }

    try {
      const result = await run(agent, text, { session: conversationSession });
      console.log(`\nAssistant: ${result.finalOutput}\n`);
    } catch (e) {
      console.error('Error:', e instanceof Error ? e.message : e, '\n');
    }

    rl.prompt();
  });

  rl.on('close', () => {
    console.log('\nSession ended.');
    process.exit(0);
  });
}

main().catch((err) => {
  console.error('Fatal error:', err);
  process.exit(1);
});

Conclusion

This was a starter code for integrating Gift up MCP with OpenAI Agents SDK to build a functional AI agent that can interact with Gift up.

Key features:

  • Hosted MCP tool integration through Composio's Tool Router
  • SQLite session persistence for conversation history
  • Simple async chat loop for interactive testing
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS

Supported Tools

Every Gift up action and event your agent gets out of the box.

Add Note to Order

Add a note of up to 500 characters to an existing order for internal tracking.

Create Item

Tool to create a new item for sale in the Gift Up checkout.

Create Item Group

Tool to create a new item group for organizing items in the Gift Up checkout.

Create Order

Tool to create a new order which generates one or more gift cards.

Delete Item

Tool to delete an item from the Gift Up checkout.

Delete Item Group

Tool to delete an item group by its ID.

Delete Webhook

Tool to delete a webhook subscription by its ID.

Get Checkout Settings

Retrieve the current checkout settings for the Gift Up account.

Get Company Details

Tool to retrieve company details.

Get Email Settings

Retrieve the Gift Up account's default email settings, including sender details and gift card and receipt email configuration.

Get Gift Card by Code

Retrieve a gift card by its code to view its balance, status, and transaction history.

Get Gift Card Settings

Retrieve the Gift Up account's gift card settings, including code and barcode formats, expiration rules, and display options.

Get Item by ID

Tool to retrieve detailed information about a specific item by its ID.

Get Order by ID

Retrieve an order by ID, including customer and payment details.

API Health Check

Tool to perform a health check on the Gift Up!

Get Report Transaction

Tool to retrieve a specific transaction report by its ID.

Get Shipping Settings

Retrieve the Gift Up account's shipping settings for digital and postal fulfilment.

Get Stripe Connection

Tool to retrieve current Stripe integration connection settings.

Get Webhook

Tool to retrieve a specific webhook by its ID.

List Gift Card Artwork

Tool to list all gift card artwork available for use on gift cards.

List Gift Cards

List a page of Gift Up gift cards, optionally filtering by status, creation or update date, and payment transaction ID.

List Item Groups

Tool to list item groups.

List Items

Lists all items (gift cards, passes, etc.) available for sale in the Gift Up account.

List Locations

Retrieves all physical locations where gift cards are sold and/or redeemed.

List Promotions

List the Gift Up account's checkout promotions and their details.

List Report Transactions

Tool to list report transactions with optional filters.

List GiftUp Users

Tool to list all users.

List Webhooks

Tool to list all webhooks configured for the account.

Health Check (POST)

Perform a Gift Up API health check by posting an optional test payload to /ping.

Reactivate Gift Card

Tool to reactivate a voided gift card.

Redeem Gift Card

Redeem a specified currency amount or units from a gift card.

Redeem Gift Card In Full

Tool to redeem a gift card in full.

Subscribe to Webhook

Subscribe to Gift Up!

Top Up Gift Card

Top up an existing gift card by code, supplying a positive currency amount and optionally units.

Undo Gift Card Redemption

Tool to undo a previous redemption on a gift card, restoring the redeemed amount to the gift card balance.

Update Email Settings

Tool to update email settings using JSON Patch operations.

Update Gift Card

Update a Gift Up gift card by code using JSON Patch operations, for example to change recipient details, expiry dates or terms.

Update Gift Card Settings

Tool to update gift card settings using JSON Patch operations.

Update Item

Update an item's properties using JSON Patch operations.

Update Item Group

Tool to update an item group's properties using JSON Patch operations.

Update Order

Update an order's properties using JSON Patch replace operations, such as changing the purchaser's name or email.

Update Stripe Connection

Update Gift Up Stripe connection settings, including API keys, Connect settings and payment methods.

Upload Gift Card Artwork

Upload new gift card artwork from an image URL.

Void Gift Card

Void a gift card by code so it cannot be redeemed while voided.

FAQ

Frequently asked questions

Start with Gift up.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Gift up tool your agent needs.Free to start.

Start building