23/9/2025AI commerce

Building ACP Endpoints for the Emerging AI Commerce Market

ACPAI

As soon as OpenAI and Stripe released the Agentic Commerce Protocol (ACP), we wanted to see what it would actually take to implement it. This post breaks down how ACP works, how we built the required endpoints in Nimara Storefront, the challenges we ran into, and what we think about implementing it at this early stage.

At the end of September 2025, OpenAI, in collaboration with Stripe, announced Instant Checkout, a feature built on top of ACP. The protocol defines how AI agents can interact directly with online stores, enabling users to discover and purchase products within a conversation.

Users can now ask ChatGPT to help them find and buy products from merchants who adopt ACP in their e-commerce.

diagram showing how Agentic Commerce Protocol works

What’s the Difference Between Instant Checkout and ACP?

Think of ACP as the language AI agents use to communicate with online stores – a standardized set of rules and endpoints that make it possible for an AI to browse, understand, and buy.

Instant Checkout, on the other hand, is the product built and named by OpenAI, in partnership with Stripe, based on the ACP – the practical feature users see inside ChatGPT. Other It’s the final step where everything happens naturally inside a chat window: product discovery, comparison, and payment.

To put it simply:

ACP is the infrastructure — the plumbing that connects AI agents and online stores.
Instant Checkout is the interface — the moment it all comes to life for the user.

You can think of ACP as the “protocol” behind the curtain, and Instant Checkout as the “showtime” that users get to enjoy. Just mind you: “Instant Checkout” is a proper name, given by OpenAI. Other providers may brand similar experiences differently – for instance, Google calls theirs “Express Checkout.” Regardless of the name, it’s ACP doing the work behind the scenes.

Implementation: Concrete Setup

In Nimara Storefront, we have implemented four core API endpoints required by the ACP specification:

/product_feed - an endpoint to expose the product catalog to AI agents, updated every 15 minutes, includes product details like SKU, price, availability, images, etc.
/checkout_sessions - an endpoint to create checkout sessions
/checkout_sessions/{id} - an endpoint to retrieve and update the checkout session status - used for updating items, buyer info, shipping address and shipping method
/checkout_sessions/{id}/complete - an endpoint to complete the purchase

In order to keep our code organized, we created a new Next.js API route in our directory specifically for the ACP endpoints, as shown below:

├── app
│   ├── ... other directories and files
│   ├── api
│   │   ├── ...other API routes
│   │   ├── acp
│   │   │   └── [channelSlug]
│   │   │       ├── checkout_sessions
│   │   │       │   ├── [id]
│   │   │       │   │   ├── complete
│   │   │       │   │   │   └── route.ts
│   │   │       │   │   └── route.ts
│   │   │       │   └── route.ts
│   │   │       └── product_feed
│   │   │           └── route.ts

Every endpoint contains an extensive logging mechanism to help us monitor the requests and responses, as well as any errors that may occur during the process. This logging is crucial for debugging, and it guarantees a smooth user experience.

To preserve the modularity and reusability of our code, we defined an ACPService interface that outlines the required methods for handling checkout sessions and product feeds according to the ACP specification. This interface can be implemented by any e-commerce platform (e.g., Saleor, Shopify) to ensure compatibility with ACP simply by extending the interface.

export interface ACPService {
  createCheckoutSession: (args) => CheckoutSession;
  updateCheckoutSession: (args) => CheckoutSession;
  getCheckoutSession: (args) => CheckoutSession;
  completeCheckoutSession: (args) => CheckoutSession;
  getProductFeed: (args) => ACPResponse<{
    pageInfo: PageInfo;
    products: ProductFeed;
  }>;
}

Every type, e.g. `ProductFeedItem` or `ProductFeed` is created using the zod library, so we can easily validate incoming requests and responses from our API endpoints against the ACP specification.

export const productFeedItemSchema = z.object({
  enable_search: z.boolean().optional().default(true),
  enable_checkout: z.boolean().optional().default(true),
  id: z.string(),
  title: z.string(),
  description: z.string(),
  price: z.number().nonnegative(),
  link: z.string().url(),
  availability: z.enum(["in_stock", "out_of_stock"]),
  currency: z.string(),
  inventory_quantity: z.number(),
  // ... other fields skipped for brevity
});

export type ProductFeedItem = z.infer<typeof productFeedItemSchema>;

export type ProductFeed = ProductFeedItem[];

We were able to fully implement the required ACP endpoints in the Nimara Storefront within two weeks. The implementation is modular and can be easily adapted to other e-commerce platforms by implementing the ACPService interface.

Navigating Implementation Challenges

1. How to work with multiple channels

At Mirumee, we often work with multi-channel e-commerce setups, where a single Saleor instance can serve multiple channels, e.g., for different countries or regions. Each channel can have its own product price, currency, and availability.

The ACP specification does not provide clear guidelines on how to handle multiple channels. That's why we decided to prefix the ACP endpoints with a dynamic channelSlug parameter, so that the AI agent can specify which channel it wants to interact with. This way, we can be sure that the correct product prices and availability are returned for each channel.

Unfortunately, this means that an average e-commerce platform needs to implement several ACP endpoints for each channel it supports. This can lead to increased complexity and maintenance overhead.

Hopefully, future versions of the ACP specification will provide clearer guidelines on how to handle multi-channel setups, so that e-commerce platforms can implement ACP more easily with just one set of endpoints.

Maybe a standard query parameter like channel or a custom HTTP header can be used to specify the channel context for the requests.

2. Mapping your data model to the ACP schema

The ACP specification defines a specific schema for the product feed and checkout sessions. However, our e-commerce platform (Saleor) has its own data model and structure. We had to carefully map the ACP schema to Saleor's data model, ensuring that all required fields are populated correctly.

This required a deep understanding of both the ACP specification and Saleor’s data model. Other e-commerce platforms may face similar challenges, especially if their data structures differ significantly from the ACP schema. Some fields don’t have a direct mapping but are still mandatory according to the specification.

3. How to handle idempotent requests on the BFF endpoint

The AI agent may send the same request multiple times, so we had to ensure that our implementation is idempotent. For example, when updating a checkout session, we check if the request with the Idempotency-Key header has already been processed. If so, we return the same response as before, instead of creating a new checkout session.

For this, we built a simple in-memory cache that stores the responses for 24 hours. For a production-ready solution, we strongly encourage you to use a more robust and scalable approach, like Redis or a database table to store the idempotent request responses.

type CachedResponse = {
  // fields we want to cache
};

// Cache for 24 hours
const CACHE_DURATION = 24 * 60 * 60 * 1000; 

// Simple, in memory cache storage
const storage = new Map<string, CachedResponse>();

class IdempotencyStorage {
  set(key: string, data: unknown): void {
     // Logic for saving the data in storage
  }

  get(key: string): CachedResponse | null {
     // Logic for retrieving the data from storage
  }
}

4. Lack of pagination in the product feed

We often work with large product catalogs that can contain thousands of products. Without pagination, it’s impossible to upload large data catalogs, which means we either have to select specific products to return in the /product_feed endpoint or we only upload a small portion of our catalog, e.g., the top N bestsellers or products from a specific category.

This limits the usefulness of the ACP integration, because AI agents will not have access to the full product range.

We end up adding a cursor-based pagination mechanism in the /product_feed endpoint, allowing AI agents to request products in smaller, paginated chunks. However, this is not part of the current ACP specification, so it may not be compatible with all AI agents in the future.

Hopefully, future versions of the ACP specification will include pagination support for the product feed, so that e-commerce platforms can efficiently push large product catalogs without any unnecessary workarounds.

Should You Implement ACP Now?

Definitely yes, if you want to be prepared for the future of e-commerce. The Instant Checkout feature is expected to become more popular in the coming years since more AI agents and e-commerce platforms adopt the ACP specification.

By implementing the required endpoints now, you will gain a competitive advantage. When the feature becomes widely available and stable, your platform will offer an unparalleled shopping experience to your customers.

Definitely not, if you expect a production-ready, stable, and fully-featured solution right away. The ACP specification is still in its early stages and is available only for US merchants. This means that there may be bugs, missing features, and compatibility issues with different e-commerce platforms.

If you are looking for a stable and reliable solution, it may be better to wait until the ACP specification matures and more merchants adopt it.

Is the Instant Checkout Available Globally?

Currently, the Instant Checkout feature is available to merchants in the US only. Merchants from platforms like Etsy or Shopify are eligible to use this feature. Opening it to more platforms and countries is expected to happen in 2026.

Costs and ROI

Adding these endpoints to our storefront took less than two weeks for two developers. This rapid implementation demonstrates the potential for quickly integrating ACP into existing e-commerce platforms.

As the ACP evolves and becomes more mature, you might consider transitioning from a Next.js API endpoint to a dedicated application architecture. This could involve using serverless functions, like AWS Lambda, to handle specific tasks related to the Instant Checkout feature.

By decoupling these functionalities from your main application, you can achieve better scalability, maintainability, and performance. This approach allows you to leverage the benefits of serverless computing while ensuring that your e-commerce platform remains responsive to the needs of your users.

When considering the return on investment (ROI) for implementing the Instant Checkout feature, it's essential to evaluate the potential costs and benefits on a case-by-case basis. Factors such as transaction fees from OpenAI's API usage fees can impact the overall profitability of the solution.

Merchants should carefully analyze their specific use cases, customer behavior, and expected sales volume to determine whether the investment in ACP is justified.

Summary

The Agentic Commerce Protocol and Instant Checkout are changing how e-commerce works, making it possible for AI agents like ChatGPT to handle transactions from start to finish. The standard is still new and evolving, but implementing ACP early can position your platform for future success in the ever-changing landscape of online commerce.

By following best practices and staying informed about updates to the specification, you can rest assured that your e-commerce platform is ready to meet the needs of modern consumers when the standard matures.

The community is already creating issues and PRs on the ACP GitHub repository to improve the specification and address some of the challenges we faced during our implementation. Why not join the conversation and help shape how AI commerce develops?