Standalone module

Integrations and Extensibility

Cross-cloud connectivity for API Extensions, Payment Methods API, and Commerce MCP

Ask about this Page

Copy for LLM

View as Markdown

After completing this page, you should be able to:

Utilize the Correlation ID feature in API Extensions for simplified request tracing and debugging across integrated systems.
Implement cross-cloud connectivity for API Extensions, specifically for Google Cloud, to enhance service communication security and performance.
Summarize the key benefits of the new Payment Methods API for orchestrating various payment services.
Explain the developer impact of the new Checkout API support in the SDKs.
Describe the purpose and potential applications of the commerce MCP (Model Context Protocol) for AI agents.

API Extensions

Correlation IDs

In a microservices architecture, finding the "needle in the haystack" requires a common thread: the Correlation ID. In 2025, commercetools extended support for this ID to API Extensions, closing a major visibility gap.

Before this enhancement, extensions were often "black boxes." Developers had to manually match timestamps to link errors.

Correlation IDs enable:

Seamless Tracing: tools like Datadog or Jaeger can stitch together the entire request lifecycle.
Faster Troubleshooting: search logs by ID to see exactly what input an extension received and why it failed.
Auditability: maintain a consistent trail for sensitive operations like price overrides.

A Correlation ID is a unique UUID assigned to a single API request. Its journey now looks like this:

Origin: a client sends a request with an X-Correlation-ID header (or commercetools generates one).
Extension trigger: before processing, commercetools triggers an API Extension.
Propagation: commercetools forwards the same X-Correlation-ID to your extension destination (AWS Lambda, Google Cloud, or HTTP).
Logging: your extension extracts and logs this ID, linking its internal logic to the platform request.

For developers, this requires a simple shift in logging patterns:

Extract: capture X-Correlation-ID from the incoming request headers or Lambda event.
Inject: use a logging library to include this ID in every log line generated during that execution.
Forward: if your extension calls a third-party service (for example, a tax provider), pass the ID along to maintain the chain.

This update complements API Extension Tracing. While the platform logs extension success/failure, linking those events to your internal function logs provides the "missing link" for enterprise-grade monitoring.

By leveraging Correlation IDs, you ensure your custom logic is no longer a blind spot in your monitoring stack, but a fully traceable component of your ecosystem. To begin implementing these patterns in your own projects, check out the Tracing requests with Correlation IDs tutorial.

Consistent API Extension Triggers

Since we are on the topic of API Extensions, we have resolved the behavior of API Extensions when they include multiple conditional triggers for the same resource type. The conditions are now correctly associated with their specific actions, resulting in more logical processing.

Previously, if a resource type had several triggers, a condition could be met, causing the API Extension to fire even if the action did not correspond to the event. For instance, a condition intended for a Create action might inadvertently trigger an Order Update.

With this fix, the trigger's condition is only evaluated when the exact corresponding action occurs. Therefore, an Update action will now only check the condition designated for the Update action. This ensures a clean and precise execution.

Import API

The Import API is like a "bulk delivery service" for your data. While the regular API is great for small, instant changes (like a customer changing their password), the Import API is built to handle thousands of items at once—like uploading an entire season's worth of products or updating prices across every store.

And over the last year, we made the Import API even better!

New Import Request Types

The Import API can now handle more types of data than ever before, specifically for complex business setups:

Business Units: you can now bulk-upload entire company structures, including departments and regional offices. This is a lifesaver for B2B companies moving away from old legacy systems.
Product Selections: if you need to decide which products show up in which stores, you can now manage those lists in huge batches rather than one at a time.

Import API Event notifications

In the past, to see if a big upload was finished, your system had to "poll" the API—basically asking, "Is it done yet?" proactively. Now, we have introduced Event notifications. With this new feature, you can subscribe to Events in the Import API.

By subscribing to Import API event notifications, you can improve your import experience with automatic, real-time status updates. This eliminates manual polling, and you receive proactive communication on the progress of your imports.

Import Container Limits and Cleanup

As businesses grow, they sometimes leave too many "empty boxes" (or Import Containers) lying around. To keep the platform running smoothly, two new rules were added in 2025:

Container Limits: there is now a limit on how many active Import Containers you can have at once (1000). This encourages teams to reuse the same containers for daily tasks instead of creating new ones every time.
Retention Policy: you can now create Import Containers with an automatically applied retention policy, which triggers automatic deletion. This enhancement improves resource management by eliminating the need for manual deletion of temporary Import Containers, making it ideal for workflows that generate many short-lived containers. Existing Import Containers, created before this release remain unaffected by this feature.

By using these new features, you can move massive amounts of data into commercetools while keeping your system organized and your team informed in real-time.

Payment Methods API

In 2025, we launched the Payment Methods API, centralizing how payment options like Credit Cards or PayPal are managed.

Instead of hardcoding payment providers into your frontend, your website can now dynamically fetch active methods from the backend. This allows you to toggle payment options on or off, update descriptions in multiple languages, and store country-specific configurations without needing to redeploy code. By moving this logic to the API, businesses gain the flexibility to adapt their checkout experience instantly.

Checkout

In 2025, we introduced two key updates to streamline and monitor the final steps of the customer journey:

SDK Support for Checkout: the Checkout API is now natively supported in the official Composable Commerce SDKs (including Java and TypeScript). This allows developers to use type-safe, standard tools instead of manual HTTP requests, making code cleaner and easier to maintain.
Checkout Event Notifications: your backend can now receive real-time updates whenever a checkout status changes. This enables "reactive" workflows, such as instantly triggering fulfillment processes or updating external tracking systems the moment a customer completes their purchase.

These enhancements simplify the technical implementation of checkout while providing better visibility into the transaction lifecycle.

Commerce MCP

How can you trust an AI assistant to give customers accurate shipping dates or prices when Large Language Models (LLMs) are prone to hallucinations and rely on outdated training data?

This is the core problem that Commerce MCP (Model Context Protocol) solves. Introduced in 2025, it acts as a universal "USB-C port" for AI, grounding AI agents in your project’s real-time truth.

In the past, LLMs "guessed" answers based on training data that was months old. To get real-time facts, developers had to build complex, brittle integrations for every new AI tool. Commerce MCP replaces these with a standardized connection that lets AI agents directly "read" your live catalog, inventory, and orders.

commercetools provides two distinct versions of the MCP to serve different stages of the commerce lifecycle. While both use the same underlying protocol, they target different data sources and users:

Feature	Commerce MCP	Developer MCP
Primary Goal	Executing business actions	Writing and validating code
AI Output	"I've added that to your cart."	"Here is the correct GraphQL schema."
Data Scope	Your private project data	Public documentation & schemas
Security	Private (needs API credentials)	Public (no login required)
IDE Integration	Limited (mostly for agents/bots)	Primary (Cursor, VS Code, JetBrains)

Which one should you use?

Use Developer MCP if you are currently writing code and want your AI assistant to stop hallucinating field names or outdated API patterns.
Use Commerce MCP if you are building an AI-powered shopping assistant or an automated support tool that needs to interact with real customer data.

Integrations and Extensibility

Cross-cloud connectivity for API Extensions, Payment Methods API, and Commerce MCP

API Extensions.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Correlation IDs.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Consistent API Extension Triggers.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Import API.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

New Import Request Types.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Import API Event notifications.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Import Container Limits and Cleanup.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Payment Methods API.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Checkout.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Commerce MCP.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}

Test your knowledge.css-c0cbbx{display:inline-block;}.css-c0cbbx >:disabled{pointer-events:none;}