Enable Stripe ACP on Your Store: Step-by-Step

const express = require('express');
      const stripe = require('stripe')('sk_live_your_key_here');

      const app = express();
      app.use(express.json());

      // Agent checkout endpoint
      app.post('/api/agent-checkout', async (req, res) => {
        const { productId, quantity = 1 } = req.body;

        // Fetch product from your database
        const product = await getProductById(productId);

        if (!product) {
          return res.status(404).json({ error: 'Product not found' });
        }

        try {
          const session = await stripe.checkout.sessions.create({
            mode: 'payment',
            agent_commerce: {
              enabled: true,
              allowed_agents: ['chatgpt', 'perplexity'],
            },
            line_items: [
              {
                price_data: {
                  currency: 'usd',
                  product_data: {
                    name: product.name,
                    description: product.description,
                    images: [product.imageUrl],
                    metadata: {
                      gtin: product.gtin,
                      sku: product.sku,
                    },
                  },
                  unit_amount: product.priceInCents,
                },
                quantity: quantity,
              },
            ],
            shipping_address_collection: {
              allowed_countries: ['US', 'CA', 'GB'],
            },
            shipping_options: [
              {
                shipping_rate_data: {
                  type: 'fixed_amount',
                  fixed_amount: { amount: 0, currency: 'usd' },
                  display_name: 'Free shipping',
                  delivery_estimate: {
                    minimum: { unit: 'business_day', value: 5 },
                    maximum: { unit: 'business_day', value: 7 },
                  },
                },
              },
              {
                shipping_rate_data: {
                  type: 'fixed_amount',
                  fixed_amount: { amount: 1500, currency: 'usd' },
                  display_name: 'Express shipping',
                  delivery_estimate: {
                    minimum: { unit: 'business_day', value: 1 },
                    maximum: { unit: 'business_day', value: 2 },
                  },
                },
              },
            ],
            success_url: `${process.env.DOMAIN}/success?session_id={CHECKOUT_SESSION_ID}`,
            cancel_url: `${process.env.DOMAIN}/cancel`,
          });

          res.json({ sessionId: session.id, url: session.url });
        } catch (err) {
          console.error('Agent checkout error:', err);
          res.status(500).json({ error: 'Checkout session creation failed' });
        }
      });

The key difference from a standard Stripe Checkout session is the agent_commerce object. Setting enabled: true tells Stripe this session can be initiated by an AI agent. The allowed_agents array restricts which agents can use it.

Include complete product data in product_data. AI agents use the name, description, and images to display the product to the customer within the chat interface. The metadata.gtin field helps agents match your product to the one the customer originally asked about.

// Webhook handler for agent checkout events
      app.post('/webhooks/stripe', express.raw({ type: 'application/json' }), (req, res) => {
        const sig = req.headers['stripe-signature'];
        let event;

        try {
          event = stripe.webhooks.constructEvent(
            req.body,
            sig,
            process.env.STRIPE_WEBHOOK_SECRET
          );
        } catch (err) {
          return res.status(400).send(`Webhook Error: ${err.message}`);
        }

        switch (event.type) {
          case 'agent_checkout.session.completed':
            const session = event.data.object;
            // session.agent_commerce.agent_name -> 'chatgpt'
            // session.agent_commerce.agent_session_id -> unique session
            // session.payment_status -> 'paid'
            fulfillOrder(session);
            break;

          case 'agent_checkout.session.expired':
            // Handle abandoned agent checkout
            releaseInventory(session);
            break;
        }

        res.json({ received: true });
      });

The webhook payload includes the agent_commerce object with details about which AI agent initiated the transaction. Use this metadata for analytics, customer support, and dispute resolution.

# Install Stripe CLI if you haven't
      brew install stripe/stripe-cli/stripe

      # Login to your Stripe account
      stripe login

      # Trigger a test agent checkout event
      stripe trigger agent_checkout.session.completed

      # Listen for webhook events locally
      stripe listen --forward-to localhost:3000/webhooks/stripe

After triggering the test event, confirm that your webhook handler processed it and your fulfillment logic triggered. Check the Stripe Dashboard for the test transaction details including the agent name and session metadata.

{
        "@context": "https://schema.org",
        "@type": "Product",
        "name": "TrailRunner Pro Hiking Boot",
        "description": "Waterproof hiking boot with Vibram sole",
        "image": "https://yourstore.com/images/trailrunner-pro.jpg",
        "gtin14": "00012345678905",
        "offers": {
          "@type": "Offer",
          "price": "189.00",
          "priceCurrency": "USD",
          "availability": "https://schema.org/InStock"
        },
        "potentialAction": {
          "@type": "BuyAction",
          "target": {
            "@type": "EntryPoint",
            "urlTemplate": "https://yourstore.com/api/agent-checkout?productId=trailrunner-pro",
            "actionPlatform": [
              "https://schema.org/DesktopWebPlatform",
              "https://schema.org/MobileWebPlatform"
            ]
          }
        }
      }

When an AI agent crawls your product page, it finds the BuyAction and knows exactly where to send the checkout request. Combined with ACP, this creates a complete loop: discovery through schema, transaction through Stripe.