Monetizing your ChatGPT app, and the Agentic Commerce Protocol

OpenAI recently brought monetization capability to the ChatGPT apps SDK. Now, you can bring a monetization experience to your ChatGPT app. OpenAI currently offers two monetization options, external checkouts, or their new instant checkout feature which is currently available for marketplace beta partners.

The new monetization features are powered by their existing Agentic Checkout Spec, which is a way for merchants to run end to end checkouts within ChatGPT. This is an exciting monetization opportunity for developers and companies wanting to tap into OpenAI's distribution potential.

In this article, we take a look into how the Agentic Commerce Protocol (ACP) works, and how you can bring instant checkouts to your ChatGPT app.

How to implement instant checkout (beta)

I assume you have some general understanding of how to build ChatGPT apps, and the windows.openai API. If you don't, I highly recommend starting off by reading some of OpenAI's docs.

Triggering an instant checkout is really simple, it's an extension of the window.openai API. You call the window.openai.requestCheckout() function, and pass in an object that's the shape of a ACP checkout session:

function CheckoutScreen() {
  const handleCheckout = async () => {
    window.openai.requestCheckout({
      id: "checkout_123",
      payment_provider: {
        provider: "stripe",
        merchant_id: "demo_merchant_123",
        supported_payment_methods: ["card", "apple_pay", "google_pay"],
      },
      status: "ready_for_payment",
      currency: "USD",
      line_items: [
        {
          id: "line_item_wilson_basketball",
          item: {
            id: "wilson_evo_basketball",
            quantity: 1,
          },
          base_amount: 6499,
          discount: 0,
          subtotal: 6499,
          tax: 520,
          total: 7019,
        },
      ],
      totals: [
        { type: "items_base_amount", display_text: "Items", amount: 6499 },
        { type: "tax", display_text: "Tax", amount: 520 },
        { type: "total", display_text: "Total", amount: 7019 },
      ],
      links: [
        { type: "terms_of_use", url: "https://example.com/terms" },
        { type: "privacy_policy", url: "https://example.com/privacy" },
      ],
      messages: [
        {
          type: "info",
          content_type: "plain",
          content:
            "Mock ACP session built from the monetization spec. No real charges are made.",
        },
      ],
      payment_mode: "test",
    });
  };

  return (
    <div className="panel">
        <Button color="primary" onClick={handleCheckout} >
          Checkout
        </Button>
    </div>
  );
}

ChatGPT then reads the ACP session object that you passed in, and opens up a modal that initiates the instant checkout flow.

Once your customer has engaged with your checkout flow, OpenAI sends a callback to your MCP server / app. OpenAI requires that you expose a complete_checkout tool. This tool is where you actually handle the payment process of connecting with your PSP (Stripe, Ayden, etc.), and make the order on your backend.

A brief look at the Agentic Commerce Protocol

OpenAI is pushing for the Agentic Commerce Protocol, a way for AI agents, customers, and businesses to communicate transactions. The structure of ACP is designed to allow agents to reason about purchases. There are two main actors in the ACP, ChatGPT and the merchant, each with its own responsibilities in the protocol.

ChatGPT is the user's purchasing agent and renders the checkout UI directly in ChatGPT. It maintains the checkout sessions, and communicates to the merchant. Most of the work is done on the merchant side.

The merchant handles the logic of purchasing an item. The merchant exposes API endpoints that allow ChatGPT to send the user's action. The merchant handles the inventory validation, fulfillment, pricing and taxes, handling the order decision. They also handle the connection with payment service providers if they wish.

There's much more to the ACP, and I highly recommend readers check out their entire docs

How to test your ChatGPT app's checkout flow locally

The MCPJam inspector is the local emulator for ChatGPT and MCP Apps, allowing you to instantly preview, debug, and iterate on your app's UI without needing to ngrok or a ChatGPT subscription.

We're excited to announce support for local testing for app checkouts. We've implemented the window.openai.requestCheckout API so you can preview your checkout flow before deploying to ChatGPT. Our emulator will also call your complete_checkout tool to simulate successful and failed transaction actions.

Try it out on the latest version of MCPJam! We have a npx command and desktop apps.

npx @mcpjam/inspector@latest