• A Shopify store, any plan.
• An OpenAI API key (pay-as-you-go).
• Optional: a ChatGPT Plus, Team, or Enterprise seat for Custom GPTs.
• 30 minutes for function calling. 10 minutes for MCP via the Responses API. 60 minutes for a polished Custom GPT.

Function calling is the original tool-use API. You declare your Shopify operations as JSON schemas; ChatGPT emits structured calls; your backend executes them.

Step 1 — Create a Shopify Custom App

Same as for Claude. Settings → Apps and sales channels → Develop apps → Create an app. Grant scopes per use case (start read-only).

Step 2 — Wire up OpenAI

import OpenAI from "openai"

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })

const tools = [
  {
    type: "function",
    function: {
      name: "get_products",
      description: "Lists products from the connected Shopify store.",
      parameters: {
        type: "object",
        properties: {
          first: { type: "number" },
          query: { type: "string", description: "Optional Shopify query" },
        },
        required: ["first"],
      },
    },
  },
] satisfies OpenAI.ChatCompletionTool[]

let messages: OpenAI.ChatCompletionMessageParam[] = [
  { role: "system", content: "You are a Shopify ops analyst." },
  { role: "user", content: "Audit my catalog." },
]

while (true) {
  const completion = await openai.chat.completions.create({
    model: "gpt-5.4",
    messages,
    tools,
  })
  const msg = completion.choices[0].message
  messages.push(msg)
  if (!msg.tool_calls) break

  for (const call of msg.tool_calls) {
    const args = JSON.parse(call.function.arguments)
    const result = await callShopify(call.function.name, args)
    messages.push({
      role: "tool",
      tool_call_id: call.id,
      content: JSON.stringify(result),
    })
  }
}

The loop runs until ChatGPT returns plain text. Standard tool-use pattern, identical to Claude's — only the field names differ.

Pros + cons

| Pros | Cons | |---|---| | No extra server | Locked to OpenAI's tool format | | Works in any environment | Every needed tool declared upfront | | Simple to debug | No intermediate state streaming |

OpenAI's Responses API supports MCP servers natively (since GA 2025). Same MCP server as for Claude. Same tool definitions. One integration, two LLMs.

import OpenAI from "openai"

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })

const response = await openai.responses.create({
  model: "gpt-5.4",
  input: "Audit my product catalog. Return the top-10 PDPs to fix.",
  tools: [
    {
      type: "mcp",
      server_url: "https://mcp.boostecom.app/shopify-admin",
      authentication: { type: "bearer", token: process.env.MCP_TOKEN },
    },
  ],
})

The Responses API handles the entire tool loop server-side. You ship the MCP server URL once; ChatGPT discovers the tools, calls them, and returns the final answer.

→ The managed MCP endpoint is part of the BoostEcom platform — /marketplace/mcp/shopify-admin ships both a self-host package AND a managed URL.

Why MCP wins long term

• Provider-agnostic — your MCP server keeps working when GPT-6 ships, when Claude Opus 5 ships, when Gemini 3 ships.
• Tool reuse — the same update_metafield tool used by ChatGPT is used by Claude in the BoostEcom workflow runner.
• Audit log — MCP lifecycle events (tool discovery, invocation, result, error) are structured. Easy to ship to Datafast or your own log drain.

For consumer-facing or internal team use cases, a Custom GPT is the fastest distribution channel. Anyone with ChatGPT Plus / Team / Enterprise can find your GPT in the picker and chat with your Shopify store.

4-step setup

1. Open ChatGPT → "Explore GPTs" → "Create a GPT".
2. Configure name, description, behavior ("you audit Shopify stores").
3. Actions → import an OpenAPI 3.1 spec describing your Shopify tools (a thin wrapper around the BoostEcom API or your own).
4. Authentication: API key or OAuth.

When to pick this path

• ✅ You want to distribute your AI workflow to non-technical users.
• ✅ Your tools are read-only or mostly-read (write actions go through human approval).
• ❌ You need multi-store routing.
• ❌ You need to embed the chat in your own UI.
• ❌ You need conversational history persisted server-side.

For anything beyond a single-store demo, Path A or B beats Custom GPTs.

Same principles as in the Claude article: start read-only, observe, gate writes behind human approval. Two ChatGPT-specific notes:

1. Function calling can hallucinate arguments. Always validate args against your JSON schema BEFORE calling Shopify. ChatGPT can emit first: "ten" when you expect first: 10.

2. Custom GPTs share session memory across users on Team/Enterprise plans when configured that way. Read OpenAI's data-handling docs before distributing a GPT that touches customer PII.

| Dimension | Function calling | MCP via Responses API | |---|---|---| | Setup time | 30 min | 10 min | | Glue code | ~100 lines | ~10 lines | | Streaming | Yes | Yes | | Multi-LLM portability | Locked to OpenAI | Works with Claude, Gemini | | Server needed | None | One MCP server | | Best for | Quick scripts, single use case | Production, multi-LLM, fleets |

→ At BoostEcom we ship MCP first because it's the right long-term answer. Function calling remains available for short scripts and BYOK power users.

The managed MCP endpoint is the visible part. The hidden parts:

• AI Gateway routing — the platform routes Claude for deep audits, ChatGPT for fast operator chat. The switch is a toggle, not a refactor.
• OIDC + BYOK — your OpenAI key lives wherever your security policy wants it (BoostEcom account, your account, or rotated per org).
• Per-org credit ledger — usage tracked per organization, not per user. Stripe webhook reconciliation built in.
• AI Elements UI — drop-in chat surface with streaming, code blocks, citations. No reinvented Markdown.
• Workflow orchestration — turn a ChatGPT call into a durable multi-step workflow with retries, timeouts, and crash safety.

→ See /features/ai-copilot for the full surface.

Can I use Custom GPTs without writing OpenAPI?

Technically yes — ChatGPT can introspect a free-text tool description. In practice you'll want OpenAPI for any tool that mutates Shopify state, because the spec doubles as contract documentation.

What's the cheapest way to test?

Path B (MCP via the Responses API) on OpenAI's free tier. The BoostEcom free plan includes daily ChatGPT credits — connect a Shopify store and start a chat in five minutes.

Does ChatGPT's function calling support streaming?

Yes — pass stream: true to chat.completions.create. Tool calls stream as deltas that you assemble client-side. The Responses API streams natively.

Can I migrate from function calling to MCP later?

Yes. Tool definitions translate cleanly. The orchestration loop shrinks from ~100 lines to ~10. We've migrated several DIY customers to the BoostEcom MCP layer in under an hour each.

What about ChatGPT Plus's "Memory" feature?

It's separate from your integration's session state. Memory is shared across the user's ChatGPT sessions. Your Shopify integration's conversational context lives in your backend (or in the BoostEcom session store).