Spryker Documentation

Integrate with Spryker

Mon, 16 Mar 2026 18:45:56 +0000

Integrating third-party services into a Spryker project is a crucial part of extending and customizing your commerce solution to meet unique business needs. Whether you're connecting payment providers, logistics systems, marketing tools, or customer support platforms, Spryker offers a flexible and scalable architecture designed to support smooth integrations. This article describes the various methods available for integrating external systems with Spryker, from using APIs and middleware to leveraging Spryker's modular architecture.

## Spryker integrations Spryker integrations are connections between a Spryker commerce system and external third-party services or internal enterprise systems. These integrations allow Spryker to exchange data, trigger actions, and extend its functionality beyond the core platform to create a tailored and scalable commerce solution. Spryker's modular architecture is built to support a wide range of integrations, whether you're connecting to payment gateways, ERP systems, CRMs, PIMs, shipping providers, or marketing tools. Integrations can range from simple REST API connections to complex, event driven data flows. At their core, integrations follow these design principles: - Decoupled: Don't interfere with the core logic. - Scalable: Ready to handle growth and high-volume transactions. - Maintainable: Easy to update or swap out services when needed. - Customizable: Flexible to fit unique business requirements. ## Integration methods

ECO modules

Spryker Eco Modules are prebuilt, reusable integration packages that connect Spryker with popular third-party services and tools. They help teams save development time and ensure reliable integrations.

Find out more

Custom build

For more tailored or business specific needs, you can build custom integrations directly in your project code.

Find out more

Spryker APIs

Spryker APIs—primarily the Glue API—provide a RESTful interface for interacting with the Spryker Commerce OS. They enable external systems, services, and frontend applications to communicate with Spryker in a structured, secure way.

Find out more

Community contributions

Spryker has an active developer community that contributes to the ecosystem by sharing modules, integrations, and improvements.

Find out more

## How integrations work Integrations connect external services to your Spryker project through modular, decoupled components. These can be built and used by any of the described integration methods depending on your use case and needs.

Release notes 202602.0

Mon, 16 Mar 2026 16:18:37 +0000

Spryker Cloud Commerce OS is an end-to-end solution for digital commerce. This document contains a business-level description of new features and improvements. For information about installing Spryker, see [Getting started guide](/docs/dg/dev/development-getting-started-guide). ## B2B Business-Ready Commerce Experiences ### Product Attachments {% include badge.html type="feature" %} Introduces out-of-the-box Product Attachments capability commonly required in industrial B2B purchasing. {% include carousel.html images="https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/product_attachments_storefront_pdp.png||::https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/product_attachments_backoffice_pim.png||" %} **Key capabilities** - Back Office management of product-related documents (for example, datasheets, certificates, manuals). - Provide external links to product attachments via data import. - Display and download or view attachments on the product details page. **Business benefits** - Supporting buyers' decisions by providing more detailed product information. - Removes approval bottlenecks and shortens the path from product view to first transaction. **Documentation** - [Product Attachments overview](/docs/pbc/all/product-information-management/latest/base-shop/feature-overviews/product-feature-overview/product-attachments-overview.html) - [Install the Product Attachments feature](/docs/pbc/all/product-information-management/latest/base-shop/install-and-upgrade/install-features/install-the-product-attachments-feature.html) ### Product & Merchant Offer Availability Display {% include badge.html type="feature" %} Introduces native, configurable product and merchant offer availability display for B2B Commerce and Marketplace scenarios, reducing customization and increasing buyer confidence at the point of decision. **Key capabilities** - Native availability display on the product details page (PDP) and in the cart - Configurable display logic: - Availability indicator only (for example Available / Out of Stock) - Exact stock quantity combined with indicator - Configuration option for the sort order of merchant offers in the B2B Marketplace - Built on existing Spryker stock data structures **Business benefits** - Buyers see reliable availability information at the point of decision. - Businesses no longer need custom implementations for basic stock visibility. - Transparent stock visibility increases direct orders and reduces operational overhead. **Documentation** - [Product Availability Display feature overview](/docs/pbc/all/warehouse-management-system/latest/base-shop/product-availability-display-feature-overview) - [Buy Box feature overview](/docs/pbc/all/offer-management/latest/marketplace/buy-box-feature-overview) ### Backoffice Configuration Framework {% include badge.html type="feature,early-access" %} Introduces a structured, extensible framework to expose business-relevant configuration directly in the Spryker Back Office without code changes or redeployments. **Key capabilities** - Structured Business Configuration via UI - Developers define configuration options in YAML once. - The framework automatically renders validated Back Office UI pages. - Runtime Configuration Without Deployment - Configuration changes are applied at runtime, no code change, no pull request, no deployment required. - Support for Out-of-the-Box and Custom Features. The framework works for: - Standard Spryker features - Project-specific customizations - Built-in Validation & Guardrails - Business users can only adjust explicitly defined and validated options, preventing misconfiguration. **Business benefits** - Faster Time to Change - Business teams adjust approved behaviors instantly, no development sprint required. - Lower Total Cost of Change - Reduces repetitive engineering effort for configuration updates and eliminates custom UI builds per feature. - Faster Experimentation - Test different configuration setups (for example display logic, marketplace sorting) without waiting for release cycles. ### B2B-only Mode Enablement Reduces project setup time for customers and partners who want B2B Commerce only, without Marketplace complexity. **Key capabilities** - Added a **guideline and deployment script** to start the unified demo shop in a standardized **B2B Commerce–only mode**, reducing required manual cleanup and configuration. **Business benefits** - Faster project initialization for B2B-only projects. - Lower implementation cost and reduced efforts. - Clearer positioning and smoother kick-off experience. **Documentation** - [Uninstall the Marketplace from B2B Demo Marketplace](/docs/about/all/uninstall-marketplace-from-b2b-demo-marketplace) ### New Industrial Homepage Sample Data {% include badge.html type="improvement" %} The new sample data allows you to explore more realistic B2B Commerce journeys and capabilities without needing to import your own data. **Key capabilities** - Updated homepage content to industrial goods and services across key blocks (banners, featured categories, featured products, top sellers). **Business benefits** - More realistic demos that reflect real industrial buying journeys. - Faster evaluations by showing realistic catalog and merchandising scenarios out of the box. - Less manual demo preparation for partners and solution teams. ### UX & Design Improvements for Storefront & Back Office {% include badge.html type="improvement" %} Improves clarity, consistency, and perceived quality across core pages and navigation. {% include carousel.html images="https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/Menu Icons.png||::https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/Empty_status_page.png||::https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/Toast_notifications.png||" %} **Key capabilities** - Redesigned the Back Office 404 page with clear recovery actions and consistent styling, removing technical error output for a smoother user experience. - Improved empty states for Addresses, Orders, and Returns pages in storefront to guide users with clear next steps and better first-time usability. - Updated navigation to Google Material Icons for visual consistency with the Merchant Portal. - Replaced full-width banner of toast notifications with stacked, auto-dismissing toast notifications for lightweight, non-disruptive feedback. - Fixed Back Office form validation errors showing untranslated message keys (restored translation rendering). **Business benefits** - Faster task completion and reduced confusion in Back Office operations. - Better first-time experience for B2B customers on key storefront pages. - Higher perceived product quality and consistency for enterprise users. - Reduced support noise caused by unclear errors and untranslated validation messages. ### PunchOut: cXML Compatibility in Spryker API ![feature](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/feature.png) Enables standardized B2B PunchOut integrations via cXML support. **Key capabilities** - Support for **cXML (Commerce XML)** as an additional data exchange format in the Spryker API Platform. - Documentation and guidance for implementing PunchOut integrations with external eProcurement systems. **Business benefits** - Enterprise-ready B2B integration API Compatibility with leading procurement platforms. - Simplified implementation of PunchOut scenarios for customers and partners. - Stronger positioning in complex B2B commerce environments. **Documentation** - [PunchOut Development Plan](/docs/integrations/custom-building-integrations/punchout-development-plan) ## Connected, and AI-Enabled Platform ### Spryker AI Foundation: Operable, Structured, and Extensible AI Runtime {% include badge.html type="early-access,improvement" %} Enhances the AI Foundation runtime layer to make AI executions easier to operate at scale, safer to integrate into product code, and more extensible for evolving use cases. **Key capabilities** - Prompt responses now return **token usage** and **applied AI configuration details** (for example, provider/vendor, model, configuration name, and relevant parameters) for improved transparency and troubleshooting. - Added **structured response support** aligned with **Spryker Transfers**, enabling validated, contract-based AI outputs rather than fragile free-text parsing. - Introduced a supported **tool call extension mechanism** for AI Foundation, enabling standardized enrichment of tool call inputs/outputs without project-specific integration workarounds. **Business benefits** - Improved cost and performance control through token visibility and configuration traceability. - More reliable production integrations through typed, validated AI outputs (reduced downstream breakage from phrasing changes). - Lower long-term maintenance and support effort via a standardized extension mechanism for evolving AI use cases. **Documentation** - [AI Foundation](/docs/pbc/all/ai-foundation/latest/ai-foundation.html) - [Install the AI Foundation module](/docs/dg/dev/ai/ai-foundation/ai-foundation-module.html) - [Use AI tools with the AiFoundation module](/docs/dg/dev/ai/ai-foundation/ai-foundation-tool-support.html) - [Use structured responses with the AiFoundation module](/docs/dg/dev/ai/ai-foundation/ai-foundation-transfer-response.html) ### Spryker AI Commerce: Agent Foundations and Smart PIM Improvements {% include badge.html type="early-access,improvement" %} Adds foundational capabilities for advanced agent workflows and improves the Back Office Smart PIM with safer, more reliable AI-assisted product description support. **Key capabilities** - **Conversation history** support to maintain context across interactions, enabling better multi-step workflows. - Introduced a **workflow orchestration layer** for predictable multi-step AI executions, including structured transitions, error handling, and auditability. - Back Office Smart PIM: **AI assistance for product descriptions** directly within abstract and concrete product create and edit pages: - Actions to **Translate content** and **Improve content** - Review-before-apply workflow to avoid accidental overwrites - Backoffice Smart PIM: **Clear user feedback when AI is not configured or unavailable**: - Validates provider credentials before calling external AI services - Shows user-facing error messages instead of silent empty responses - Logs operator-friendly errors without exposing secrets - UI safeguard disables AI actions with an explanatory tooltip when AI is not configured **Business benefits** - Higher adoption and trust in AI features due to clear error states and safer interaction patterns. - Faster catalog enrichment through translation and content improvement with less manual effort and fewer review loops. - Foundation for advanced B2B agent scenarios through context continuity and orchestrated workflows. - Improved governance and auditability through workflow execution traceability. **Documentation** - [Smart Product Management](/docs/pbc/all/product-information-management/latest/base-shop/third-party-integrations/smart-product-management/smart-product-management.html) - [Install Smart Product Management](/docs/pbc/all/product-information-management/latest/base-shop/third-party-integrations/smart-product-management/install-smart-product-management.html) - [Manage conversation history with the AiFoundation module](/docs/dg/dev/ai/ai-foundation/ai-foundation-conversation-history.html) - [AI workflow orchestration with state machines](/docs/dg/dev/ai/ai-foundation/ai-foundation-workflow-state-machine.html) ### Spryker AI Dev SDK: Additional MCP Tools for Spryker-Aware AI Development {% include badge.html type="early-access,improvement" %} Expands MCP tooling to make Spryker context retrieval, module discovery, documentation grounding, and demo data manipulation faster and more reliable for AI-assisted development. **Key capabilities** - Added `getSprykerModuleMap` MCP tool to return **comprehensive module information**, including: - Paths and core API components (Facade, Client, Service, Config) - Available plugin interfaces and extension points - Added `getSprykerModules` MCP tool to return a **simplified flat list** of unique module names for efficient discovery and reduced token usage. - Added a **Spryker documentation** MCP tool supporting: - Docs web URL - GitHub tree URL for the markdown source - GitHub API URL for raw markdown retrieval - Added **read-only database access** tooling for agents to retrieve required information without manual user intervention (SQL query input). - Added MCP tools to accelerate **import/demo data workflows**: - CSV structure analysis (without loading full content) - CSV transform operations (update/replace/append) - Row deletion by filter criteria - ODS-to-CSV export per sheet (supporting Google Sheets → Spryker import pipelines) **Business benefits** - Faster and more accurate AI-assisted development through Spryker-aware context (module APIs, extension points, docs grounding). - Reduced onboarding time and fewer integration mistakes for developers and agents. - Improved productivity for solution teams by standardizing CSV/ODS workflows and reducing failed import cycles. - Lower token usage and faster tool responses due to simplified module discovery outputs. **Documentation** - [AI Dev SDK Overview](/docs/dg/dev/ai/ai-dev/ai-dev-overview) - [AI Dev MCP Server](/docs/dg/dev/ai/ai-dev/ai-dev-mcp-server) ### API Platform improvements {% include badge.html type="improvement" %} This release enhances API Platform capabilities to improve your developer experience and reduce manual configuration overhead. **Key capabilities** - Enable support for relationships in API Platform. - Add support for custom validation constraints (FQCN-based) in schema definitions. - Improve dependency resolution for API Platform packages. - Add support for Code Buckets. - Provide API test examples to help you adopt the features more easily. **Business benefits** - Generate and validate API resources more cleanly and consistently. - Reduce the need for manual dependency fixes. - Improve consistency in your API implementations. - Accelerate onboarding and increase developer productivity. **Documentation** - [Validation Schemas](/docs/dg/dev/architecture/api-platform/validation-schemas.html) - [Code Buckets](/docs/dg/dev/architecture/api-platform/code-buckets.html) - [Relationships](/docs/dg/dev/architecture/api-platform/relationships.html) - [API Test Examples](/docs/dg/dev/architecture/api-platform/testing.html) ### OMS New Visual User Experience {% include badge.html type="improvement" %} Spryker transforms the community-driven OMS visualizer into a fully validated and productized capability. ![Screenshot of the OMS visualizer showing order state machine transitions](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/2026-OMS-visualizer.png) **Key capabilities** - Provides a streamlined visualization of complex Order State Machines (OMS). **Business benefits** - Enables faster OMS iteration cycles and improves clarity when you develop or validate OMS processes. - Reduces the time you spend debugging OMS flows by providing better visibility and tooling support. **Documentation** - [Original Community Contribution](https://github.com/spryker-community/oms-visualizer) - Documentation for the productized version is coming soon. ### Messaging and scheduling modernization {% include badge.html type="improvement" %} We introduced Symfony Messenger and Symfony Scheduler as modern, flexible alternatives to the current RabbitMQ adapter and scheduling mechanisms in Jenkins. **Key capabilities** - Feature toggle that lets you switch between RabbitMQ and Messenger without breaking compatibility. - Migration path and supporting documentation to help you transition. - Messenger becomes the default queue adapter. - Scheduler lets you control the job schedule from within your application. **Business benefits** - Gain greater flexibility in queue transport configuration. - Align scheduling with the Symfony ecosystem using a modern approach. **Documentation** - [Symfony Messenger](/docs/dg/dev/integrate-and-configure/integrate-symfony-messenger.html) - [Symfony Scheduler](/docs/dg/dev/integrate-and-configure/integrate-symfony-scheduler.html) ### Secure handling of customer data in quote requests {% include badge.html type="improvement" %} This update improves the quote request storage mechanism to ensure that the system does not unnecessarily persist sensitive customer data in version records. Previously, the `spy_quote_request_version` table stored the complete quote JSON, which could include full company customer data, including encrypted passwords. Although the passwords were encrypted, storing them outside the dedicated customer table increased the risk of exposure and did not follow the principle of data minimization. **Key capabilities** - Removes unnecessary storage of sensitive customer data, such as encrypted passwords, from the `spy_quote_request_version` table. - Ensures that customer credentials remain stored exclusively in the `spy_customer` table. - Improves secure data handling in quote request versioning flows that the Storefront triggers. **Business benefits** - Reduces the risk of confidential data exposure. - Strengthens compliance with secure data handling and data minimization principles. - Improves overall database hygiene and reduces the attack surface. **Documentation** - [Quote Request](https://api.release.spryker.com/release-group/6300) ### Platform & Tooling Upgrades {% include badge.html type="improvement" %} We have updated critical application and service components to long-term supported versions to ensure continued stability, performance, and compatibility. **Key capabilities** - Upgraded PHPUnit to version 12 (full PHP 8.3 support, improved test data handling). - Upgraded PHPStan to version 2.x to reduce memory consumption and significantly improve performance. - Upgraded Angular to the latest supported major version 20. **Business benefits** - Faster CI pipelines and reduced waiting times for static analysis. - Continued alignment with PHP ecosystem and Angular support lifecycles. - Resolved a vulnerability in `@angular/common` affecting Spryker applications. The issue (CVE-2025-66035) allowed potential XSRF token leakage via protocol-relative URLs in Angular HTTP clients, potentially exposing CSRF tokens to attacker-controlled domains. - Improved quality assurance and development tooling performance across projects. **Documentation** - [Upgrade to Angular 20](https://docs.spryker.com/docs/dg/dev/upgrade-and-migrate/upgrade-to-angular-20.html) - [Release unlocking the new PHPUnit version](https://api.release.spryker.com/release-group/6334) - Spryker is fully compatible with PHPStan 2.x, update it at your own schedule. ### Quality, Performance & Stability Fixes {% include badge.html type="improvement" %} This release resolves several performance bottlenecks and technical inconsistencies identified in customer projects. **Key capabilities** - Improved Stock Data Import performance by removing the usage of `\ProductAbstractCheckExistenceStep` and `\ProductConcreteCheckExistenceStep`, which eliminates unnecessary full database loads. - Preserved correct HTTP error codes by returning 4xx responses for expected application errors, such as invalid cart operations, instead of 500. - Optimized customer session validation by removing resource-intensive password hash checks. - Stabilized OpenTelemetry monitoring and New Relic instrumentation to prevent memory issues and improve trace grouping for Zed and Gateway traffic. - Fixed concrete product publishing and product filter handling, including whitelist-aware category suggestions and hidden facets, to restore complete and consistent search results. - Corrected the Data Import CSV reader configuration so that offset and limit options work as expected for partial imports. - Restored Back Office form validation translations and eliminated redundant SQL execution in category rules. - Improved cart behavior in the Glue API by merging guest carts with product bundles on login and introducing SKU-level quantity restriction plugins. **Business benefits** - Improved backend performance and reduced database and CPU load. - Delivered more reliable and predictable product search, filtering, and category navigation for end users. - Enabled more stable imports and storefront builds with safer customizations and improved dependency management. - Improved Back Office and cart usability to reduce operational overhead and user friction. - Add guidance to the public Spryker documentation on how to adopt the Cypress boilerplate. **Documentation** - See [Spryker Releases](https://api.release.spryker.com/release-history) or use `composer` to update all packages. - [E2E Testing with Cypress](/docs/dg/dev/guidelines/testing-guidelines/cypress-testing.html) ### Architecture Guidelines ![improvement](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/improvement.png) A set of practical, reusable guidelines to reduce delivery risk, prevent recurring implementation pitfalls, and standardize engineering practices across Spryker projects. **Key capabilities** - **APM monitoring and troubleshooting using New Relic** - Standardized end-to-end troubleshooting workflow (metrics → transactions → DB queries → traces). - Clear mapping of New Relic entities to Spryker applications (Yves, Zed, Glue, Merchant Portal). - Practical examples for diagnosing common performance issues. - **Performance best practices: common challenges and optimization strategies** - Documented top recurring performance pitfalls from real projects (symptoms, root cause patterns, proven optimizations). - Guidance on recognizing issues via response time, query patterns, and logs. - **How to start a Spryker project** - Step-by-step setup guidance covering project structure, CI/CD basics, team practices, and quality tooling. - Focus on "must-do" principles to avoid rework and long-term quality degradation. **Business benefits** - Faster onboarding for partners and new project teams through standardized, actionable guidance. - Reduced escalation rate by addressing known recurring delivery and performance pitfalls early. - Improved project consistency and upgradeability through repeatable architecture and documentation patterns. - Better diagnosability and prevention of performance degradation with a shared troubleshooting methodology. **Documentation** - [APM — New Relic based troubleshooting](/docs/dg/dev/guidelines/performance-guidelines/apm-newrelic-based-troubleshooting.html) - [Perfromance best practices](/docs/dg/dev/guidelines/performance-guidelines/performance-guidelines.html) - [Updated how to start Spryker project](/docs/dg/dev/development-getting-started-guide.html) ### Architecture as Code for Spryker projects ![improvement](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/improvement.png) Live, version-controlled architecture documentation using industry standards that scales with your codebase. Enables team collaboration, decision traceability, and onboarding without custom tooling or specialized training. **Key capabilities** - Ready-to-use architecture templates for living, version-controlled architecture documentation that evolves with your code, based on arc42 (12 sections) and the C4 model (4-level visualization). - Traceable architectural decision templates through Solution Designs (RFC-style exploration) and ADRs. - Diagrams as code using Mermaid and PlantUML, with real examples for automated validation, generation, and AI analysis. **Business benefits** - Faster onboarding - with globally-recognized standards and all needed architecture documentation in one place - your code - Better decision making - RFC-style exploration and full decision history eliminate tribal knowledge - Alignment with business - Capture project requirements, trade-offs before implementation, ensuring delivery matches intent. Evolve further with architecture decision records and Solution designs - AI-ready format - Markdown and code-based diagrams enable intelligent automation and documentation generation **Documentation** - [Architecture as a Code](/docs/dg/dev/architecture/architecture-as-code.html) ### ERP Integration Template ![improvement](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/improvement.png) Provides a standardized foundation for building ERP integrations without starting from scratch. **Key capabilities** - Reusable module structure (Client and Shared layers) with transfer object definitions. - Pre-built base classes (`BaseRequest`, `BaseRequestBuilder`) for: - Request handling and timeout configuration - Headers and authentication - Logging and error management - Request/response mapper pattern for ERP-specific format transformations. - Guzzle client configuration guidance with environment-specific credentials and connection setup. **Business benefits** - Faster ERP integration development with reduced boilerplate. - Consistent architecture across projects and ERP systems. - Lower risk of integration defects due to standardized logging and error handling. - Improved maintainability and onboarding for new ERP integrations. **Documentation** - [ERP Integration Template](/docs/integrations/custom-building-integrations/erp-integration-template.html) ### Payment Integration Template (PSP Template) ![improvement](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/improvement.png) Delivers a production-ready template repository for building payment service provider (PSP) integrations. **Key capabilities** - Covers all mandatory integration touchpoints with the SCCOS that must be considered when integrating a payment provider (business logic, configurations, OMS, frontend forms) and payment lifecycle handling, with practical implementation examples. - Support for core payment flows: **Authorize → Capture → Cancel**. - Two payment method templates (for example Credit Card, Invoice) including: - OMS state machines for synchronous and asynchronous authorization. - Webhook infrastructure: - Payload logging - Signature validation - Route provider setup - Data import configuration with payment method CSV templates and glossary translations (EN, DE). - Automated module renaming and setup guidance to accelerate project adoption. - Comprehensive integration checklist to ensure no required system part is missed during implementation. **Business benefits** - Reduced development time for new PSP integrations - Consistent payment architecture and OMS alignment across projects. - Improved reliability through standardized webhook and lifecycle handling. - Clear separation of module developer and project integrator responsibilities. **Documentation** - [PSP Integration Template](/docs/integrations/custom-building-integrations/psp-integration-template.html) ### New Algolia Eco-Module Integration ![improvement](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/improvement.png) Replaces the legacy Algolia App model with a code-visible eco-module. **Key capabilities** - New Algolia integration as a standard Spryker eco-module. - Full code visibility and extensibility for customers and partners. - Support for current Algolia Search license–related features. - Updated documentation for integration and customization. **Business benefits** - Increased flexibility and customization options. - Reduced dependency on black-box App Spryker support and evolution implementations. - Better alignment with project-level architecture and extension patterns. **Documentation** - [Integrate Algolia](/docs/pbc/all/search/latest/base-shop/third-party-integrations/algolia/integrate-algolia.html) ## Efficient and Flexible Cloud Foundation ### Cloud Self-Service Portal update {% include badge.html type="improvement" %} The Cloud Self-Service Portal is now available on a new platform that improves usability and accelerates value delivery. {% include carousel.html images=" https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/cloud-hub1.png||:: https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/cloud-hub2.png||:: https://spryker.s3.eu-central-1.amazonaws.com/docs/About/Releases/release-notes-202602/cloud-hub3.png||" %} **Key capabilities** - Spryker has moved the Cloud Self-Service Portal to a new platform to provide a better user experience and faster value delivery. - In the new portal, you can access centralized Single Sign-On (SSO) management. **Business benefits** - Provides a structured migration path to Single Sign-On (SSO) to help you simplify access management. **Portal access** - [Customer Portal](https://portal.spryker.com/) ### RabbitMQ 4.1 rollout {% include badge.html type="improvement" %} This update completes the rollout of RabbitMQ 4.1 across all platform environments. **Key capabilities** - Upgrade to RabbitMQ 4.1 for improved messaging infrastructure. - Platform-wide rollout to ensure consistency across environments. **Business benefits** - Improved stability and performance of asynchronous processing. - Enhanced scalability for event-driven workloads. - Reduced operational risk through alignment with the latest supported messaging version. **Documentation** - [Docker SDK service configuration](/docs/dg/dev/integrate-and-configure/configure-services.html) - [System Requirements](/docs/dg/dev/system-requirements/latest/system-requirements.html) ### Security RSS feed: Docker image updates {% include badge.html type="improvement" %} This update integrates Docker image security release notes into the official Spryker security RSS feed, ensuring timely notifications for infrastructure updates. **Key capabilities** - RSS Feed Integration: Docker image security releases are now automatically published to the security RSS stream (/feed-security.xml) - Automated Visibility: Real-time visibility of image-related security patches alongside standard application news. **Business benefits** - Improved Security Posture: Ensures DevOps and Security teams are immediately alerted to infrastructure-level vulnerabilities and patches. - Streamlined Compliance: Easier tracking and auditing of container image versions through a centralized, standardized feed. - Proactive Maintenance: Reduces the window of exposure by eliminating the need to manually check for image updates. **Documentation** - [Spryker Security RSS Feed](/feed-security.xml) - [Release notes](/docs/about/all/releases/product-and-code-releases.html)

App Composition Platform

Mon, 16 Mar 2026 15:40:39 +0000

Warning

The Spryker App Composition Platform is being sunset. No additional activations or changes are allowed. Contact your Spryker representative if you require additional information.

App Composition Platform (ACP) enables you to connect, configure, and use the available third-party services with zero or low development effort. For business information about ACP, see Spryker App Composition Platform.

ACP supports the following integrations:

INTEGRATION	DESCRIPTION
Vertex	Tax compliance.
Algolia	Search engine.
Payone	Payment service provider.
Bazaarvoice	Platform for user-generated content.
Stripe	Financial infrastructure platform.

ACP components

ACP consists of the following components:

App catalog: The interface for managing all ACP apps. The App catalog provides details about an integration, enables users connect to the ACP and add configurations to connect to a third-party app. It can be accessed via the Spryker Back Office.
App Composition Platform and infrastructure: The underlying platform for the ACP facilitates defining how Spryker projects communicate with third-party integrations via the ACP.
ACP apps: Integrations provided by Spryker by default via the ACP. Spryker offers a range of zero to low-code applications.

Installing the ACP Catalog

The ACP Catalog in the Back Office is available since version 202212.0.

To run ACP Catalog with an earlier version, install the spryker/app-catalog-gui module version 1.4.1 or higher.

Register for ACP

To use ACP apps, you need to register your project with ACP. The registration process prepares your project for seamless communication with the third-party apps. To register your project, follow the steps:

Install prerequisites and enable ACP.
To set up infrastructure, contact us.

If you need help with the registration process or have any questions, send us a message.

How to migrate to API Platform

Mon, 16 Mar 2026 09:15:05 +0000

This document describes how to migrate existing Glue API resources to the API-Platform while maintaining backward compatibility. ## Overview Migrating from Glue API to API Platform provides several benefits: - **Schema-based development**: Define resources declaratively in YAML instead of PHP code - **Automatic OpenAPI documentation**: Interactive API docs generated from schemas - **Reduced boilerplate**: No need for manual resource builders, mappers, and route definitions - **Built-in validation**: Declarative validation rules with operation-specific constraints - **Standardized pagination**: Consistent pagination across all resources - **Better maintainability**: Clearer separation of concerns with providers and processors The migration can be done gradually, resource by resource, without breaking existing API consumers. ## Prerequisites Before migrating resources, ensure you have: - Integrated API Platform as described in [How to integrate API Platform](/docs/dg/dev/upgrade-and-migrate/integrate-api-platform.html) - Configured router plugins in correct order (see below) - Tested that API Platform is working with at least one test resource ## Migration strategy The migration follows a **gradual replacement** approach: 1. **Coexistence**: Both Glue API and API Platform run side by side 2. **Router priority**: Existing Glue endpoints are matched first, API Platform endpoints second 3. **Resource-by-resource**: Migrate one resource at a time, verify, then move to the next 4. **No breaking changes**: Existing API consumers continue to work during migration 5. **Final cleanup**: Remove Glue router only after all resources are migrated ### Router configuration order The key to gradual migration is router plugin order. The `SymfonyFrameworkRouterPlugin` must be placed **after** existing Glue router plugins: `src/Pyz/Glue/Router/RouterDependencyProvider.php` ```php */ protected function getRouterPlugins(): array { return [ new GlueRouterPlugin(), // ← Existing Glue endpoints (checked first) new SymfonyFrameworkRouterPlugin(), // ← API Platform endpoints (checked second) ]; } } ``` {% info_block warningBox "Router order is critical" %} If `SymfonyFrameworkRouterPlugin` is placed before `GlueRouterPlugin`, API Platform routes may shadow existing Glue routes and break backward compatibility. Always place it **after** existing routers. {% endinfo_block %} With this configuration: - Request comes in: `GET /customers` - `GlueRouterPlugin` checks first: If Glue resource exists → use it - `SymfonyFrameworkRouterPlugin` checks second: If no Glue match → try API Platform - Result: Existing endpoints continue working, new API Platform endpoints are available ## Migration process ### Step 1: Identify resources to migrate List all existing Glue resources in your application: Backend API resources are typically registered in: `\Pyz\Glue\GlueBackendApiApplication\GlueBackendApiApplicationDependencyProvider::getResourcePlugins()` Storefront API resources are typically registered in: `\Pyz\Glue\GlueApplication\GlueApplicationDependencyProvider::getResourceRoutePlugins()` Create a migration checklist: ```bash [ ] Customers resource [ ] Products resource [ ] Orders resource [ ] Cart resource [ ] Wishlist resource ... ``` {% info_block infoBox "Migration order recommendation" %} Start with simpler, read-only resources (GET operations only) before migrating complex resources with write operations and business logic. {% endinfo_block %} ### Step 2: Analyze existing Glue resource Before migrating, understand the existing resource structure. **Example: Existing Glue Customer Resource** 1. **Resource route plugin:** `src/Pyz/Glue/CustomersRestApi/Plugin/GlueApplication/CustomersResourceRoutePlugin.php` 2. **Resource class:** `src/Pyz/Glue/CustomersRestApi/Processor/Customer/CustomerReader.php` 3. **Attributes transfer:** `src/Generated/Shared/Transfer/RestCustomersAttributesTransfer.php` 4. **Operations supported:** - GET `/customers/{customerReference}` - Get single customer - GET `/customers` - Get customer collection - POST `/customers` - Create customer - PATCH `/customers/{customerReference}` - Update customer ### Step 3: Create API Platform schema Create the equivalent API Platform schema for the resource. **Map Glue concepts to API Platform:** | Glue API | API Platform | |---------------|--------------| | Resource class | Provider class | | Resource builder | Schema definition (YAML) | | Attributes transfer | Resource class (auto-generated) | | Reader | Provider | | Writer | Processor | | Resource route plugin | Operations in schema | | Relationship plugins | Properties in schema | **Create schema file:** `src/Pyz/Zed/Customer/resources/api/backoffice/customers.yml` ```yaml resource: name: Customers shortName: Customer description: "Customer resource for backoffice API" provider: "Pyz\\Glue\\Customer\\Api\\Backoffice\\Provider\\CustomerBackofficeProvider" processor: "Pyz\\Glue\\Customer\\Api\\Backoffice\\Processor\\CustomerBackofficeProcessor" paginationEnabled: true paginationItemsPerPage: 10 operations: - type: Post - type: Get - type: GetCollection - type: Patch properties: customerReference: type: string description: "A unique reference for a customer." writable: false identifier: true email: type: string description: "The email address of the customer." openapiContext: example: "john.doe@example.com" firstName: type: string description: "The first name of the customer." openapiContext: example: "John" lastName: type: string description: "The last name of the customer." openapiContext: example: "Doe" # Map all properties from RestCustomersAttributesTransfer ``` **Create validation schema:** `src/Pyz/Zed/Customer/resources/api/backoffice/customers.validation.yml` ```yaml post: email: - NotBlank: message: "Email is required" - Email: message: "Invalid email format" firstName: - NotBlank: message: "First name is required" lastName: - NotBlank: message: "Last name is required" patch: email: - Optional: constraints: - Email ``` ### Step 4: Implement Provider Create the Provider to handle read operations, reusing existing business logic. {% info_block infoBox "Reuse existing business logic" %} The Provider should primarily call existing Facade methods. This ensures consistency and reduces duplication of business logic. {% endinfo_block %} `src/Pyz/Zed/Customer/Api/Backoffice/Provider/CustomerBackofficeProvider.php` ```php getCustomer($uriVariables['customerReference']); } return $this->getCustomers($context); } private function getCustomer(string $customerReference): ?CustomersBackofficeResource { // Reuse existing Glue logic $customerTransfer = $this->customerFacade->findCustomerByReference($customerReference); if ($customerTransfer === null) { return null; } // Map transfer to API Platform resource $resource = new CustomersBackofficeResource(); $resource->fromArray($customerTransfer->toArray()); return $resource; } private function getCustomers(array $context): TraversablePaginator { $filters = $context['filters'] ?? []; $page = (int) ($filters['page'] ?? 1); $itemsPerPage = (int) ($filters['itemsPerPage'] ?? 10); // Reuse existing facade method $customerCollection = $this->customerFacade->getCustomerCollection($page, $itemsPerPage); $resources = []; foreach ($customerCollection->getCustomers() as $customerTransfer) { $resource = new CustomersBackofficeResource(); $resource->fromArray($customerTransfer->toArray()); $resources[] = $resource; } return new TraversablePaginator( new \ArrayObject($resources), $page, $itemsPerPage, $customerCollection->getTotalCount() ); } } ``` ### Step 5: Implement Processor Create the Processor to handle write operations. {% info_block infoBox "Reuse existing business logic" %} The Processor should primarily call existing Facade methods. This ensures consistency and reduces duplication of business logic. {% endinfo_block %} `src/Pyz/Zed/Customer/Api/Backoffice/Processor/CustomerBackofficeProcessor.php` ```php createCustomer($data); } if ($operation instanceof Patch) { return $this->updateCustomer($data, $uriVariables['customerReference']); } return null; } private function createCustomer(CustomersBackofficeResource $resource): CustomersBackofficeResource { $customerTransfer = new CustomerTransfer(); $customerTransfer->fromArray($resource->toArray(), true); // Reuse existing facade method $customerResponseTransfer = $this->customerFacade->addCustomer($customerTransfer); $result = new CustomersBackofficeResource(); $result->fromArray($customerResponseTransfer->getCustomerTransfer()->toArray()); return $result; } private function updateCustomer(CustomersBackofficeResource $resource, string $customerReference): CustomersBackofficeResource { $customerTransfer = new CustomerTransfer(); $customerTransfer->fromArray($resource->toArray(), true); $customerTransfer->setCustomerReference($customerReference); // Reuse existing facade method $customerResponseTransfer = $this->customerFacade->updateCustomer($customerTransfer); $result = new CustomersBackofficeResource(); $result->fromArray($customerResponseTransfer->getCustomerTransfer()->toArray()); return $result; } } ``` ### Step 6: Generate API Platform resource Generate the Back Office resource class from the schema: ```bash console api:generate # Verify generation ls -la src/Generated/Api/Backoffice/CustomersBackofficeResource.php ``` Generate the storefront resource class from the schema: ```bash glue api:generate storefront ``` ### Step 7: Test the API Platform endpoint Test that the new endpoint works correctly: ```bash # Test single resource curl -X GET http://backoffice.eu.spryker.local/customers/DE--1 # Test collection curl -X GET http://backoffice.eu.spryker.local/customers?page=1&itemsPerPage=10 # Test create curl -X POST http://backoffice.eu.spryker.local/customers \ -H "Content-Type: application/json" \ -d '{"email":"test@example.com","firstName":"John","lastName":"Doe"}' # Test update curl -X PATCH http://backoffice.eu.spryker.local/customers/DE--1 \ -H "Content-Type: application/json" \ -d '{"firstName":"Jane"}' ``` Verify: - ✅ Responses match expected format - ✅ Validation rules work correctly - ✅ Error handling is appropriate - ✅ Pagination works for collections - ✅ OpenAPI documentation is generated at root URL `/` ### Step 8: Run existing Glue API tests Ensure backward compatibility by running existing tests: ```bash # Run Glue API tests vendor/bin/codecept run -c tests/PyzTest/Glue/CustomersRestApi # Or specific test vendor/bin/codecept run -c tests/PyzTest/Glue/CustomersRestApi/RestApi/CustomerRestApiCest ``` All existing tests should still pass because: - `GlueRouterPlugin` is checked first - Existing Glue endpoints still work - No breaking changes to consumers ### Step 9: Remove Glue resource files Once the API Platform endpoint is working and tested, remove the old Glue files: ```bash # Remove resource route plugin rm src/Pyz/Glue/CustomersRestApi/Plugin/GlueApplication/CustomersResourceRoutePlugin.php # Remove processor classes rm -rf src/Pyz/Glue/CustomersRestApi/Processor/ # Update dependency provider to remove plugin registration ``` **Update GlueApplicationDependencyProvider:** `src/Pyz/Glue/GlueApplication/GlueApplicationDependencyProvider.php` ```php protected function getResourceRoutePlugins(): array { return [ // new CustomersResourceRoutePlugin(), // ← Remove this line new ProductsResourceRoutePlugin(), new OrdersResourceRoutePlugin(), // ... keep other plugins ]; } ``` ### Step 10: Verify migration After removing Glue resource files: ```bash # Clear caches console cache:clear # Test that API Platform endpoint still works curl -X GET http://backoffice.eu.spryker.local/customers/DE--1 # Verify OpenAPI docs include the resource curl http://backoffice.eu.spryker.local/docs.json | jq '.paths' # Check the interactive documentation at root URL # Visit: http://backoffice.eu.spryker.local/ ``` ### Step 11: Repeat for remaining resources Repeat steps 2-10 for each resource in your migration checklist: ```bash [✓] Customers resource ← Migrated [ ] Products resource ← Next [ ] Orders resource [ ] Cart resource [ ] Wishlist resource ... ``` ## Final cleanup Once **all** Glue resources are migrated to API-Platform: ### 1. Remove GlueRouterPlugin `src/Pyz/Glue/Router/RouterDependencyProvider.php` ```php protected function getRouterPlugins(): array { return [ // new GlueRouterPlugin(), // ← Remove - no longer needed new SymfonyFrameworkRouterPlugin(), ]; } ``` ### 2. Remove empty Glue modules ```bash # Remove modules that no longer have resources rm -rf src/Pyz/Glue/CustomersRestApi/ rm -rf src/Pyz/Glue/ProductsRestApi/ # ... etc ``` ### 3. Update composer dependencies If you're no longer using Glue-specific packages: ```bash # Review and remove unused Glue packages composer remove spryker/customers-rest-api composer remove spryker/products-rest-api # etc... ``` ### 4. Clean-up tests Update or remove Glue-specific test files: ```bash # Convert tests to API Platform format or remove rm -rf tests/PyzTest/Glue/CustomersRestApi/ ``` ### 5. Update documentation Update internal API documentation to reference new endpoints: - OpenAPI documentation: `http://backoffice.eu.spryker.local/` (root URL) - OpenAPI JSON spec: `http://backoffice.eu.spryker.local/docs.json` - Update Postman collections - Update integration documentation for partners ## Migration comparison ### Before: Glue API ```bash Request: GET /customers/DE--1 ↓ GlueRouterPlugin ↓ CustomersResourceRoutePlugin ↓ CustomerReaderInterface ↓ CustomerFacade ↓ RestResourceBuilder ↓ Response: RestCustomersAttributesTransfer ``` ### After: API Platform ```bash Request: GET /customers/DE--1 ↓ SymfonyFrameworkRouterPlugin ↓ API Platform Router ↓ CustomerBackofficeProvider ↓ CustomerFacade (same!) ↓ CustomersBackofficeResource ↓ Response: JSON (auto-serialized) ``` ## Key differences | Aspect | Glue API | API Platform | |--------|----------|--------------| | **Definition** | PHP classes & plugins | YAML schemas | | **Routing** | ResourceRoutePlugin | Schema operations | | **Reading data** | Reader classes | Provider classes | | **Writing data** | Writer classes | Processor classes | | **Validation** | Manual in reader/writer | Declarative in validation schema | | **Documentation** | Separate OpenAPI schema | Auto-generated from schema | | **Response building** | Manual RestResourceBuilder | Auto-serialization | | **Relationships** | Relationship plugins | Schema properties | | **File count** | ~10-15 files per resource | ~3-5 files per resource | ## Troubleshooting migration ### Both old and new endpoints respond **Symptom:** Both Glue and API Platform endpoints return responses. **Cause:** Different URLs are being used. Check if they're actually the same: ```bash # Glue endpoint GET /customers/DE--1 # API Platform endpoint GET /customers/DE--1 # Check URL prefixes in configuration ``` **Solution:** Ensure URLs match exactly. API Platform resources use `shortName` for URL generation. ### API Platform endpoint returns 404 during migration **Symptom:** After creating schema and generating resource, endpoint returns 404. **Possible causes:** 1. Router order is wrong (SymfonyFrameworkRouterPlugin before GlueRouterPlugin) 2. Cache not cleared 3. Resource not generated **Solution:** ```bash # Check router order in RouterDependencyProvider # Should be: GlueRouterPlugin, then SymfonyFrameworkRouterPlugin # Clear caches console cache:clear # Regenerate resources console|glue api:generate backoffice # Verify generated file exists ls -la src/Generated/Api/Backoffice/CustomersBackofficeResource.php ``` ### Different response format between Glue and API Platform **Symptom:** API Platform returns different JSON structure than Glue. **Cause:** Glue uses JSON:API format, API Platform uses JSON-LD by default which is configurable and depending on your needs you can migrate to JSON-LD as well or stay with the JSON API format. API-Platform covers this possibility for you **Solution:** This is expected. You have three options: 1. **Accept the difference** (recommended): Update API consumers to handle both formats during migration 2. **Configure API Platform format**: Customize serialization to match the Glue format 3. **Use content negotiation**: Support both formats based on `Accept` header ### Business logic differs between implementations **Symptom:** API Platform endpoint behaves differently than a Glue endpoint. **Cause:** Provider/Processor uses different facade methods or has different logic. **Solution:** Review and ensure both use the same facade methods: ```php // Glue Reader $customerReader->readCustomer($customerReference); ↓ calls $this->customerFacade->findCustomerByReference($customerReference); // API Platform Provider $this->customerFacade->findCustomerByReference($customerReference); // ← Same method! ``` ## Best practices ### 1. Migrate in small batches Don't try to migrate all resources at once. Migrate in small batches for example: ```bash Sprint 1: Customers, Products (read-only) Sprint 2: Orders, Cart Sprint 3: Wishlist, Checkout ``` ### 2. Keep business logic in facades Don't duplicate business logic in Providers/Processors: ```php // ❌ Bad: Logic in Provider private function getCustomer(string $reference): ?CustomersBackofficeResource { $customer = $this->repository->findByReference($reference); // ... business logic here } // ✅ Good: Delegate to Facade private function getCustomer(string $reference): ?CustomersBackofficeResource { $customerTransfer = $this->customerFacade->findCustomerByReference($reference); return $this->mapToResource($customerTransfer); } ``` ### 3. Use toArray/fromArray for mapping Leverage generated `toArray()` and `fromArray()` methods: ```php // Easy mapping between Transfer and Resource $resource = new CustomersBackofficeResource(); $resource->fromArray($customerTransfer->toArray()); ``` ### 4. Test thoroughly before removing Glue code - Run all existing tests - Perform manual testing - Check with API consumers - Monitor production traffic ### 5. Document breaking changes If response formats differ, document changes for API consumers: ```markdown ## Migration Notice: Customers API The `/customers` endpoint is being migrated to API-Platform. ### Changes: - Response format: JSON:API → JSON-LD - Date format: unix timestamp → ISO 8601 - Error format: JSON:API errors → RFC 7807 Problem Details ### Timeline: - Old endpoint: Supported until 2026-12-31 - New endpoint: Available now - Deprecation: Old endpoint will return deprecation headers starting 2026-09-01 ``` ## Next steps - [API Platform](/docs/dg/dev/architecture/api-platform.html) - Architecture overview - [API Platform Enablement](/docs/dg/dev/architecture/api-platform/enablement.html) - Creating resources - [Resource Schemas](/docs/dg/dev/architecture/api-platform/resource-schemas.html) - Resource Schemas - [Validation Schemas](/docs/dg/dev/architecture/api-platform/validation-schemas.html) - Validation Schemas - [Troubleshooting](/docs/dg/dev/architecture/api-platform/troubleshooting.html) - Common issues

Vertex

Mon, 16 Mar 2026 08:55:32 +0000

![vertex-hero](https://spryker.s3.eu-central-1.amazonaws.com/docs/pbc/all/tax-management/vertex/vertex.md/vertex-hero.png) The Spryker Vertex module, based on the *Vertex O Series*, performs automatic, near-real-time tax calculations at the point of purchase while accounting for the following: - Tax rates in each state, county, and city. - Laws, rules, and jurisdiction boundaries. - Special circumstances like tax holidays and product exemptions. For more information about how Vertex calculates taxes, see the [Vertex O Series website](https://www.vertexinc.com/solutions/products/vertex-indirect-tax-o-series). The Spryker Vertex module offers the following features that are worth considering when comparing it to the default Spryker [Tax Management capability](/docs/pbc/all/tax-management/latest/tax-management.html): - *Configure Vertex in Spryker*: Add your Vertex configurations, including your company code, in `config/Shared/config_default.php` to connect your Spryker project to Vertex. - *Tax determination and calculation*: View tax estimates during checkout and calculated taxes before generating an invoice. This feature works across all regions, including countries where taxes are included in the price. - *Discounts Support*: The Vertex module uses both the discount and the amount paid by the customer, sending this information to Vertex for tax calculation and estimation. - *Manage tax exemptions*: Configure your project to exclude tax-exempt customers using the Vertex module. - *View invoice reports in Vertex dashboard*: The Vertex module allows customers to send invoice reports for paid orders from Spryker to Vertex. Customers can opt out of sending invoices to Spryker if they choose. - *Support for refunds*: When order items are returned, refunded, or a paid order is canceled, the Vertex module updates the tax report in Vertex for accurate reporting and compliance. - *Failover Solution*: Store owners and marketplace operators can manage refunds and ensure accurate tax reporting even during downtime. - *Supported Product Types*: The integration currently supports tax calculation only for items/products created using Spryker Product capabilities. - *Application of custom tax rules to products*: You can implement custom tax rules to accommodate unique product categorizations or specific tax regulations that apply to your business. The Vertex Integration provides a means for taxes to be calculated using these rules. ## Supported Use Cases and Business Models 1. Tax Calculation in Regions where taxes are excluded from prices. For example, in the US and Canada. 2. Tax Calculation in Regions where taxes are included in the price. For example, in the EU. 3. Marketplace: Every line item sent from Spryker to Vertex includes the customer's shipping address and the merchant's warehouse address, which Vertex uses for tax calculation. 4. Support for Delivery Terms: Vertex allows customers to set delivery terms within their dashboard, which are used in tax calculation. This is especially important for cross-border transactions when the seller wants to use the customer's location to determine the applicable tax rate. 5. Inclusion of Shipping Tax in the Total Tax Calculated: Spryker sends the selected shipping method to Vertex. The `delivery-method-key` set in Spryker is used for this purpose. Projects must ensure this is mapped correctly inside the Vertex dashboard by following the steps below: - In Vertex you create a Taxability Driver with the same value from Spryker - In Vertex you create a Taxability Mapping for the driver to one of Vertex's defined Delivery Charges The following diagram demonstrates the flow of the Vertex integration: ![vertex-flow](https://spryker.s3.eu-central-1.amazonaws.com/docs/pbc/all/tax-management/vertex/vertex.md/vertex-flow.png) ## How Vertex calculates taxes for different countries The Vertex module calculates taxes based on the tax rules and rates of the country where the product is shipped. The Vertex app uses the shipping address to determine the tax rate. In some cases, the Vertex module can't calculate taxes and returns a 0 tax rate. For example, when a seller is located in EU, and the buyer is located in the US. So, make sure your project has a logic for such cases. For example, when a buyer selects a shipping address different from the project's default tax region or country, a warehouse address in the respective region needs to be used. ## Product Class Code The Product Class Code is used to represent groups or categories of products or services with identical taxability. By default, Spryker Product SKU is sent as `LineItems[].product.value` and `LineItems.lineItemId`. The Vertex module does not create any Vertex Tax Categories. ### Item Flexible Fields Item Flexible Fields are optional fields provided by a project. They are needed for the customization of tax calculation. Flexible Fields are supported by the Vertex module, and whether or not to use them is a business decision. ## Freight tax for shipment Spryker doesn't support freight shipment in terms of big packaging support; but calculation of taxes for shipping prices is supported. ## Sending invoices to Vertex through OMS The Spryker OMS transition command is used as an execution point to send a full order with all existing and custom fields provided by the project. The results will be visible in the Invoice Tax Details report. ## Next steps [Integrate Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/integrate-vertex.html)

Verify Vertex Connection

Mon, 16 Mar 2026 08:55:32 +0000

This document describes how to verify Vertex integration. ## Prerequisites - [Install Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/integrate-vertex.html). - Create an account with [Vertex](https://www.vertexinc.com/). If you need support getting a Vertex account, contact [support](https://support.spryker.com/) or your Customer Success Manager. - Optional: For Vertex Validator integration, create an account with [Vertex Validator](https://www.vertexinc.com/). ## Verify Vertex connection {% info_block warningBox "Test the configuration" %} To ensure accuracy and compliance with tax laws, we highly recommend thoroughly testing the Vertex integration. {% endinfo_block %} Once you've configured Vertex, the taxes are calculated in real time in the checkout. A message about this is displayed on the checkout page. ![vertex_checkout_page](https://spryker.s3.eu-central-1.amazonaws.com/docs/pbc/all/tax-management/vertex/configure-vertex/vertex_checkout_page.png) On the Storefront, the tax amount is displayed on the checkout summary page. In the Back Office, the taxes are displayed on the order details page. If you configured invoices to be saved in Vertex, you can view the taxes processed by Vertex as follows: 1. In the Vertex dashboard, go to **Reporting** > **Standard Reports**. 2. Click **Report Output**. 3. Next to the report you want to view the taxes for, click **Action**>**View report**. ![vertex-report-output](https://spryker.s3.eu-central-1.amazonaws.com/docs/pbc/all/tax-management/vertex/configure-vertex/vertex-report-output.png) 4. On the invoice page, you can verify the invoice number that corresponds to the Spryker order number and the applicable country tax calculated by Vertex. ![invoice-in-vertex](https://spryker.s3.eu-central-1.amazonaws.com/docs/pbc/all/tax-management/vertex/configure-vertex/invoice-in-vertex.png) ## Verify Vertex Validator tax ID validation Validate a tax ID by sending a request to `/tax-id-validate` using Glue API. ### Request ```json { "data": { "type": "tax-id-validate", "attributes": { "countryCode": "**", "taxId": "*****" } } } ``` One of the following should be returned: Successful response: HTTP code: 200. ```json { "data": [], "links": [] } ``` Unsuccessful response: HTTP code: 400, 422. ```json { "errors": [ { "status": 400, "detail": "Wrong format of the tax number." } ] } ```

Release notes 202507.0

Mon, 16 Mar 2026 08:55:32 +0000

### Business benefits - Reduce cancellations by allowing post-checkout edits - Minimize manual customer service interventions ### Docs - [Order Amendment feature overview](/docs/pbc/all/order-management-system/latest/base-shop/order-amendment-feature-overview) - [Install the Order Amendment feature](/docs/pbc/all/order-management-system/latest/base-shop/install-and-upgrade/install-features/install-the-order-amendment-feature) ## Bulk product import in Merchant Portal {% include badge.html type="early-access" %} {% include badge.html type="feature" %} The Product Import feature in the Merchant Portal enables you to bulk upload products using a universal CSV format, streamlining workflows, reducing manual effort, and accelerating time-to-market. ![merchant-portal-import](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/all/releases/release-notes-202507.0.md/merchant-portal-import.png) ### Key capabilities - Import products, pricing, and stock in one go: Upload a single file to populate essential product data, minimizing repetitive tasks and improving data accuracy. - Simplified CSV structure: Use a clean, single-line format that supports fast onboarding and easy updates to large product catalogs. - Built-in import logs: Get immediate feedback with success and error logs to troubleshoot issues and ensure smooth uploads. ### Business benefits - Empower merchants with self-service tools - Launch and update product catalogs faster - Reduce data entry errors and manual rework ### Docs - [Install the Marketplace Merchant Portal Data Import feature](/docs/pbc/all/product-information-management/latest/marketplace/install-and-upgrade/install-features/install-the-merchant-portal-data-import-feature.html) - [Install the Marketplace Merchant Portal Product Data Import feature](/docs/pbc/all/product-information-management/latest/marketplace/install-and-upgrade/install-features/install-the-merchant-product-data-import-feature.html) ## Marketplace Discounts {% include badge.html type="improvement" %} The Marketplace Discounts enhancements introduce advanced targeting capabilities for Marketplace Operators, enabling promotions specific to individual merchants or product offers: - Merchant-specific discounts: Apply discounts exclusively to products from a specific merchant using merchant references in discount conditions. - Product offer-specific discounts: Target discounts at the product offer level for more granular promotions. ![marketplace-discounts](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/all/releases/release-notes-202507.0.md/marketplace-discounts.png) ### Business benefits - Strategic promotions: Gain full control to drive growth in specific segments, support underperforming merchants, or push high-priority inventory. - Merchant performance and retention: Equip your merchants with tools to run tailored promotions under your governance, helping them increase sales and stay competitive. ### Docs - [Install the Marketplace Merchant + Promotions & Discounts feature](/docs/pbc/all/merchant-management/latest/marketplace/install-and-upgrade/install-features/install-the-marketplace-merchant-promotions-and-discounts-feature) - [Install the Marketplace Product Offer + Promotions & Discounts feature](/docs/pbc/all/offer-management/latest/marketplace/install-and-upgrade/install-features/install-the-marketplace-product-offer-promotions-and-discounts-feature) ## Discount conditions for customer-related criteria {% include badge.html type="improvement" %} The latest discount condition enhancements introduce more precise control over customer-related promotion scenarios, enabling restrictions and targeting directly based on customer identity or behavior: - Maximum uses per customer: Limit how many times a logged-in customer can redeem a specific discount or voucher. Ideal for one-time offers, such as welcome codes, newsletter subscription rewards, or limited campaigns where repeated usage should be prevented. - Customer reference: Target a discount at a specific customer by assigning their unique customer reference. Useful for compensation vouchers, exclusive rewards, or customer-specific promotional scenarios. ![customer-discount](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/all/releases/release-notes-202507.0.md/customer-discount.png) ### Business benefits - Precision in customer targeting and control: Define exactly who can use a promotion and how often, enabling tailored experiences for first-time buyers, high-value customers, or compensation scenarios. - Increased promotion efficiency and ROI: Align discount usage with customer behavior and strategic goals, ensuring that promotions reach the right audience with the right frequency. ### Docs [Install the Customer Account Management + Promotions & Discounts feature](/docs/pbc/all/customer-relationship-management/latest/base-shop/install-and-upgrade/install-features/install-the-customer-account-management-promotions-and-discounts-feature) ## Back Office UX improvements {% include badge.html type="improvement" %} These updates make it easier to work with large data sets in the Back Office, especially across key areas like orders, products, and marketplace operations: - Advanced table filters with multi-select: Quickly narrow down results in views, such as Orders, Products, Product Offers, Merchants, and Discounts, using flexible, multi-select filters. - Search by product variant SKU: Find specific products faster by searching for concrete product SKUs in the Abstract Products list. - Measurement unit management: Back Office users can now manage measurement units, including the ability to add and maintain translations for each unit. ![BO-filter-orders](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/all/releases/release-notes-202507.0.md/BO-filter-orders.png) ### Business benefits - Operational speed and efficiency: Save time on routine tasks with faster filtering and improved search capabilities—allowing teams to process orders, manage catalogs and discounts, and support merchants more effectively. - Scalability in daily workflows: Handle high volumes of data with ease. The improved navigation and filtering ensure the Backoffice stays responsive and usable as your orders, product, and merchant base grows. ## Spryker Monitoring Integration {% include badge.html type="feature" %} Spryker Monitoring Integration integrates Spryker's monitoring data into your APM platform based on the Spryker's implementation of the OpenTelemetry framework. It enables you to unite Spryker's insights with your monitoring ecosystem, ensuring full visibility across eCommerce workflows, faster issue detection, and alignment with your monitoring best practices. ### Business benefits - Personalized application monitoring: Integrate Spryker into your monitoring platform for a tailored, customized monitoring experience. - Comprehensive tracing and health check metrics: Forward traces and health check metrics from both your application and Spryker services to enable precise performance analysis and faster anomaly detection - Consolidated monitoring: Consolidate all performance data in a singe monitoring platform, ensuring full visibility across your entire eCommerce workflow ### Docs [Spryker Monitoring Integration](/docs/ca/dev/monitoring/spryker-monitoring-integration/spryker-monitoring-integration.html) ## Configurable data exporter {% include badge.html type="feature" %} Configurable Data Exporter provides structured access to your operational data, built for flexibility, performance, and security. Export curated datasets on a scheduled basis to your own cloud storage without affecting production systems. Secure RDS-to-S3 transfers enable integration into your analytics stack, data lake, or ETL pipeline — whether for BI, ML, or advanced audits — all without added operational risk. ### Business benefits - Plug into any destination: Easily connect to your BI tools or data pipelines, from Snowflake to Looker or custom analytics platforms. - Scheduled and scalable: Automate your exports based on business cadence, ensuring consistency and performance as your data needs grow. - Governed and composable: Fine-grained control over data scope and structure means exports align with internal policies and evolving business questions. - Controlled access: Avoid direct querying of your production systems, protecting uptime while granting safe access to curated, business-critical datasets. ### Docs [Set up data export to S3](/docs/ca/dev/set-up-data-export-to-s3.html) ## Algolia as a global search {% include badge.html type="improvement" %} The Algolia ACP app is expanded to support search through content within CMS pages and PDF documents, on top of existing product catalog search. This upgrade significantly enriches the search experience, delivering more relevant and complete results. ### Business benefits - Improved user experience: Provides richer, more complete search results. - Increased content discoverability: Makes all types of information searchable. ### Docs [Algolia](/docs/pbc/all/search/latest/base-shop/third-party-integrations/algolia/algolia) [Integrate Algolia](/docs/pbc/all/search/latest/base-shop/third-party-integrations/algolia/integrate-algolia.html) ### Technical prerequisites [Install prerequisites and enable ACP](/docs/dg/dev/acp/install-prerequisites-and-enable-acp) ## Vertex Tax ID validator {% include badge.html type="feature" %} Simplify B2B invoicing and tax compliance checks with the updated Vertex ACP App. This release features direct, out-of-the-box integration of the Vertex Validator API into checkout. With Vertex Validator and Vertex ACP App, you can validate business tax IDs for syntax, validity, and location, reducing operational costs from incorrect invoices and ensuring accurate application of VAT. ### Business benefits - Automated tax ID validation during checkout or any part of the process thanks to the headless integration - Improved tax compliance through ID verification and accurate VAT application via company location data - Decreased operational costs thanks to minimized invoicing errors - Global validation in over 65 countries ### Docs [Integrate Vertex Validator](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/integrate-vertex-validator) ### Technical prerequisites - [Install prerequisites and enable ACP](/docs/dg/dev/acp/install-prerequisites-and-enable-acp) - [Install Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/integrate-vertex.html) ## Multi-Factor Authentication {% include badge.html type="improvement" %} Multi-Factor Authentication (MFA) adds an additional layer of protection by requiring users to verify their identity through multiple methods, such as a password and a one-time code sent to their email. ![MFA-email-code](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/all/releases/release-notes-202507.0.md/MFA-email-code.png) ### Key capabilities - An additional authentication layer for Storefront, Back Office, Merchant Portal, and API endpoints - Supports for custom authenticity validators, such as TOTP or Short Message - Ensures that an email address is validated before a user signs up or updates their email address ### Business benefits Improves the overall security of your project, as well as the security of each customer. ### Docs [Multi-Factor Authentication](/docs/pbc/all/multi-factor-authentication/latest/multi-factor-authentication) ## SEO Sitemap {% include badge.html type="improvement" %} The Sitemap feature generates XML sitemaps that improve SEO by helping search engines efficiently index your Storefront content. Generated sitemaps include products, categories, product sets, CMS pages, and merchant pages by default. You can configure other entities to be included on the project level. ### Business benefits Improved SEO ### Docs - [Sitemap feature overview](/docs/pbc/all/miscellaneous/latest/sitemap-feature-overview) - [Install the Sitemap feature](/docs/pbc/all/miscellaneous/latest/install-and-upgrade/install-features/install-the-sitemap-feature) ## Add to cart from images (AI-powered) {% include badge.html type="early-access" %} {% include badge.html type="feature" %} This feature enables customers to add products to cart by uploading images on the Quick Order page. Upload a PDF, image, photo of handwritten notes, or any other text mentioning products to add to cart. Based on the uploaded image, OpenAI detects matching products in your catalog and adds them to cart. A single image can contain multiple products, and they both will be added to cart. Customers need own OpenAI accounts to use this feature.

### Business benefits - Enable more buying routes - Reduce friction in transactions for power users ## Accessibility improvements {% include badge.html type="improvement" %} Accessibility ensures inclusive experiences for all users in Back Office and B2B Storefront, enhancing usability and helping customers in compliance with the 2025 EU Accessibility Act: - Keyboard usage: Users with mobility impairments can navigate seamlessly without a mouse. - Distinguishable colors: Users can easily read and interact with content, even if they have visual impairments or color blindness. B2B Strorefront has a 100% Lighthouse score in Google Chrome: ![accessibility-improvement](https://spryker.s3.eu-central-1.amazonaws.com/docs/About/all/releases/release-notes-202507.0.md/B2B-SF-Accessibility.png) ### Business benefits - Meeting regulatory requirements: reduced legal risks related to 2025 EU Accessibility Act - Inclusive user experience: Improves usability for all users, including those with disabilities - Broader market reach: Enables access for a wider audience, enhancing engagement and trust ### Docs - [Install Back Office accessibility improvements](/docs/pbc/all/back-office/latest/base-shop/install-and-upgrade/install-back-office-accessibility-improvements) - [Integrate accessibility improvements](/docs/dg/dev/integrate-and-configure/integrate-accessibility-improvements) ## Performance optimizations in cart and checkout {% include badge.html type="improvement" %} This release delivers major performance improvements to checkout, order placement, and large cart processing—ensuring a smooth and responsive experience during peak traffic and high order volumes: ### Key capabilities - Smarter order reference generation: Introduces a new random string algorithm for Sales Order References, enabling high-speed, database lock-free order placement. This approach supports faster checkouts and seamless scaling during peak demand. - Optimized support for large orders (50–100 items): key features, such as Cart, Checkout, Inventory, OMS, Discounts, Shipments, Product, and Merchant, have been fine-tuned to efficiently handle large orders. Internal benchmarks show up to 40% faster performance across Storefront, Glue API, and background OMS operations. - Improved cart page performance: The dynamic cart page now renders up to twice as fast, delivering a more responsive and seamless customer experience. ### Business benefits Smooth, efficient processing of large carts and orders, enhancing the checkout experience for both B2C and B2B customers. ### Docs - [Unique random order reference generator](/docs/pbc/all/order-management-system/latest/base-shop/unique-random-order-reference-generator) - To benefit from these improvements, make sure to update the recommended modules listed in [Performance Guidelines](/docs/dg/dev/guidelines/performance-guidelines/general-performance-guidelines.html#use-the-newest-modules) - Cart page performance is now improved. The new configuration is described in the [Cart installation guide](/docs/pbc/all/cart-and-checkout/latest/base-shop/install-and-upgrade/install-features/install-the-cart-feature#set-up-configuration) ## Valkey key-value store {% include badge.html type="improvement" %} Spryker is migrating its cache solution from Redis to Valkey, a high-performance, open-source in-memory data store, supported by AWS ElasticCache. This integration significantly enhances data processing capabilities, offering improved speed, scalability, and security. ### Business benefits - Accelerate performance: Leverage Valkey's advanced multi-threading for substantially higher throughput (up to 5x observed in tests for write operations) and more stable latencies, resulting in faster application response times, especially during peak traffic. - Enhance scalability and reliability: Benefit from Valkey's superior scaling capabilities and improved cluster failover mechanisms, ensuring your platform can robustly handle business growth and larger, more complex workloads. - Improve system efficiency: Utilize Valkey's optimized memory management for better resource utilization and overall system performance. - Future-proof your infrastructure: Redis reached its end-of-life version, so migrating to Valkey ensures ongoing security updates, a clear BSD 3-clause licensing model, and strong, long-term support backed by the Linux Foundation and major industry players. ### Docs [Use and configure Redis or Valkey as a key-value store](/docs/dg/dev/backend-development/client/use-and-configure-redis-or-valkey-as-a-key-value-store) ## Cache performance improvement: Data Compression {% include badge.html type="feature" %} Spryker is introducing seamless and efficient data compression in Valkey key-value store to enhance overall system performance and reduce latency. By minimizing the size of stored and transferred data without compromising speed, this feature optimizes data-intensive operations, leading to faster access times and more efficient use of network and storage resources. With intelligent compression levels tailored for performance, Spryker enables businesses to scale more effectively while maintaining rapid user experiences. ### Business benefits - Enhanced performance: Transparent compression in Valkey boosts application responsiveness by reducing storage overhead - Faster data transfer: Up to 50% reduction in data size leads to quicker transfers between database and Spryker applications - Reduced latency: Improved data retrieval speeds from Valkey ensure smoother, low-latency experiences for end users - Efficient compression: Uses fast compression algorithms that minimize text data without introducing performance overhead ### Docs [Advanced configuration for Redis compression](/docs/dg/dev/set-up-spryker-locally/key-value-store-configuration#advanced-configuration-for-redis-compression) ### Technical prerequisites [Use and configure Redis or Valkey as a key-value store](/docs/dg/dev/backend-development/client/use-and-configure-redis-or-valkey-as-a-key-value-store) ## Cloud self-service: Storage and access management {% include badge.html type="feature" %} Cloud Self Service is a new automated system for handling common customer support requests. This feature leverages internal tooling to process requests for IAM user creation, VPN and SSH access, and S3 bucket creation automatically, streamlining the support process and empowering customers with faster resolutions. ### Business benefits - Reduce lead times: Speed up development and operational tasks by having common requests fulfilled faster - Enhance request quality and consistency: Automated processing minimizes human error, ensuring that requests are handled accurately and consistently every time ## Cloud security improvements {% include badge.html type="improvement" %} This release introduces both internal and customer-facing enhancements, including Multi-Factor Authentication (MFA) and improved password policy, now enabled by default for all new and existing cloud users. All IAM users are now required to activate MFA and use more complex passwords by default. These measures significantly reduce the risk of credential exposure and prevent unauthorized access to your cloud environments. ### Business benefits - Enhanced account security: Multi-Factor authentication and stronger password policies safeguard your cloud environments against unauthorized access and credential misuse - Security best practices by default: Pre-configured security settings ensure a strong baseline without additional setup, making it easier to maintain a secure and resilient cloud setup ### Docs [Multi-factor authentication and passwords](/docs/ca/dev/security/multi-factor-authentication-and-passwords) ## Stable Workers {% include badge.html type="early-access" %} Introducing a significant enhancement to Publish and Synchronize (P&S) focused on increasing its job processing stability. While Jenkins continues to manage non-P&S tasks, P&S now uses a new Stable Worker Architecture. This redesign addresses stability challenges from its previous Jenkins-based execution, ensuring more reliable data synchronization (products, prices, assets), especially for large catalogs and frequent updates. The new architecture provides isolated worker contexts, automatic retries, and better error handling for a more robust P&S operation. ### Docs [Stable Workers](/docs/dg/dev/backend-development/cronjobs/stable-workers) ### Business benefits - Improved P&S performance and stability: Faster, more stable catalog data refreshes and timely frontend updates - Better handling of complex scenarios: Efficiently manage large, frequently updated catalogs - Reduced operational disruptions: Minimized downtime and manual P&S interventions due to enhanced resilience - Enhanced logging: Better visibility for logs (CloudWatch) for quicker resolution of P&S issues ## Support for GitHub Enterprise {% include badge.html type="feature" %} Spryker now offers native integration for GitHub Enterprise Server (GHES). This enhancement lets you directly connect your self-hosted GHES repositories with the Spryker platform, eliminating the previous requirement to mirror repositories. ### Business benefits - Simple, direct integration: Directly connect your GitHub Enterprise Server, removing the complexity and overhead of mirroring repositories - Streamlined workflows: Improved development and deployment workflows through a direct, native connection to your GHES infrastructure - Reduced operational overhead: Eliminate the need for maintaining and managing repository mirroring processes ## Improved autoscaling {% include badge.html type="improvement" %} Spryker Cloud Autoscaling has been enhanced with a faster reaction to traffic spikes. The measured improvement is up to five times faster to scale out from the time an event is observed. Aggressive scale out and scale-in better address temporary traffic surges–for example, during sales events–and improve the reliability of your shop. The improvements are already implemented with no action required from you. ### Business benefits - Improved reliability: Services scale five times faster - Improved end-user experience: No increase in request latency for users

Release notes 202311.0

Mon, 16 Mar 2026 08:55:32 +0000

The Spryker Commerce OS is an end-to-end solution for digital commerce. This document contains a business-level description of new features and enhancements. For information about installing the Spryker Commerce OS, see [Getting started guide](/docs/dg/dev/development-getting-started-guide.html). ## ![core-commerce](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_Spryker+Commerce+OS_128.png) Fulfillment App {% include badge.html type="feature" %} As part of Spryker's Unified Commerce capability, the Fulfillment App provides an all-new user interface designed to streamline your order fulfillment process. Supporting new business models and with enhanced functionalities, the Fulfillment App simplifies tasks for warehouse and store staff, offering an efficient and effective fulfillment process. The fulfillment App includes the following features: - New picking list concept: Compatible with many picking strategies to increase order fulfillment efficiency. - Warehouse allocation strategy: Optimize warehouse space utilization for your specific warehouse setup. - Offline mode: Ensure uninterrupted picking, even without an internet connection. - Backend API architecture: Better performance and improved scalability. - Powered by Spryker's Oryx Framework: Make rapid frontend customizations by utilizing a rich library of components. **Business benefits**: - Fulfill orders faster, easier, and smarter. - Rapidly customize and scale with a flexibly built app. ### Documentation [Fulfillment App overview](/docs/pbc/all/warehouse-management-system/latest/unified-commerce/fulfillment-app-overview.html) ## ![core-commerce](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_Spryker+Commerce+OS_128.png) Click&Collect {% include badge.html type="feature" %} With Enhanced Click&Collect, your customers now have the flexibility to choose between delivery and pickup during checkout, enhancing their shopping experience. Store operators also benefit from advanced configuration capabilities for their in-store stock. Click&Collect includes the following features: - Service points: Service points broaden the scope of services you can offer at your physical locations beyond order collection. Its adaptable framework simplifies implementing features such as return services and appointment scheduling, allowing businesses to tailor solutions to their specific needs. - Integrated shipment types at checkout: Provide your customers with the flexibility to choose between delivery and pickup during checkout. With the flexible architecture of the Enhanced Click&Collect, you can create custom shipment types, like "Ship-from-Store", on the project level. - Works seamlessly with multi-address checkout: Lets your customers divide their orders for different delivery methods. For example, they can have some items delivered to their doorstep while they pick up other items at a location they select. - Merchant Portal integration: As a store operator, you can now do the following: - Specify product availability based on different service points: physical retail outlets, warehouses, or any other pickup location. - Adjust stock availability for each service point. - Offer varied pricing for items based on their pickup or delivery location. ![click-and-collect-demo](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/release-notes-202311.0/click-and-collect.gif) **Business benefits**:
Enhanced Click&Collect facilitates immediate product availability, offering both B2B and B2C clients the convenience of bypassing wait times associated with shipping. This feature not only significantly reduces or eliminates shipping costs but also provides an opportunity for immediate product inspection, ensuring quality and specifications meet the client's standards. Moreover, it seamlessly blends the digital shopping experience with the tangible benefits of a physical store, fostering direct customer-business interactions and potentially driving additional in-store purchases. While pickup has its roots in B2C operations, its utility in B2B contexts is growing: - Automotive industry: Manufacturers and dealers can offer customers the convenience of ordering parts online with the option for on-site installation. - Manufacturing sector: Streamline operations by letting clients directly retrieve bulk orders from warehouses, enhancing the efficiency of the procurement process. ### Documentation [Service point management](/docs/pbc/all/service-point-management/latest/service-point-management.html) ## ![data](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/data.png) Data Exchange API {% include badge.html type="feature" %} Traditionally, developing APIs required technical expertise and time-consuming coding processes. However, with the new Spryker dynamic Data Exchange API infrastructure, we have removed the complexities, making it seamless for you to create APIs effortlessly. With this tool, you can quickly build, customize, and manage APIs tailored to your specific business requirements, all through an intuitive user interface. The key features of the Data Exchange API include the following: - No coding required: No complex coding and development efforts are needed. The user-friendly interface enables you to create APIs effortlessly. - Rapid API generation: The streamlined process lets you generate APIs in a matter of minutes. This helps you speed up your integration projects and get your applications up and running faster than before. - Flexibility and customization: You can tailor your API endpoints to your exact needs. You can define parameters, which allows for seamless compatibility with your systems. - Real-time updates: You can modify your API endpoints on the go. Our infrastructure allows you to make changes dynamically so you can adapt to evolving business needs without any downtime. **Business benefits**: - Reduce time-to-market, speeding up faster integration - Cost savings, especially on maintenance ### Documentation - [Data Exchange API](/docs/pbc/all/data-exchange/{{site.version}}/data-exchange.html) ### Technical prerequisites - [Install the Data Exchange API](/docs/pbc/all/data-exchange/latest/install-and-upgrade/install-the-data-exchange-api.html) [Install the Data Exchange API + Inventory Management feature](/docs/pbc/all/data-exchange/latest/install-and-upgrade/install-the-data-exchange-api-inventory-management-feature.html) ## ![data](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/data.png) Next Generation Middleware: Spryker Middleware powered by Alumio {% include badge.html type="feature" %} The Spryker Middleware powered by Alumio solves the main challenges of data integrations in a flexible and customizable way and, therefore, greatly reduces the efforts for Spryker's data exchange use cases. It is the foundation on which we build our Integration Apps. The Spryker Middleware powered by Alumio uses Alumio data integration technology. The Spryker Middleware powered by Alumio helps you to reach the following outcomes: - Lower the total cost of ownership, centralizing the management of data flows. - Lower return rate with more comprehensive & accurate product information. - Gain higher customer satisfaction by keeping consistent and up-to-date data across all touchpoints. - Gain higher conversion rate by reacting to customer demands and competitive challenges more quickly. **Business benefit**:
Faster time-to-value shortening setup times for integrations ### Technical prerequisites To connect Spryker Middleware powered by Alumio with Spryker Cloud Commerce OS, you need to install or deploy the [Data Exchange API feature](/docs/pbc/all/data-exchange/latest/install-and-upgrade/install-the-data-exchange-api.html) in your environment. ## ![data](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/data.png) Akeneo PIM Integration App {% include badge.html type="feature" %} Our Akeneo PIM Integration App simplifies the management of your product information by providing an out-of-the-box and highly flexible integration with the popular Akeneo PIM system. This saves you time and effort, allowing you to seamlessly manage your product information across all channels, resulting in a more efficient and effective sales process. The Spryker Akeneo PIM Integration App allows you to do the following: - Reduce time to market and set up a product data synchronization feed between Spryker and Akeneo PIM without any coding. - Easily adapt to any changes in your data model with intuitive, visual data mapping capabilities. - Increase the reliability of your data flow between Spryker and Akeneo PIM with buffering, retries, and extensive troubleshooting capabilities. **Business benefit**:
Reduce time-to-market with a flexible integration to Akeneo PIM, keeping new product information synchronized at the rhythm your business demands. ### Technical prerequisites - To use your Akeneo PIM Integration App, you need to have the Spryker Middleware powered by Alumio. - The Akeneo PIM Integration App works with B2C or B2B business models of Spryker Cloud Commerce. Currently, it doesn't cover the Marketplace business models. ## ![cloud](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_Spryker+Cloud_128.png) Log forwarding and metric streaming to Dynatrace {% include badge.html type="feature" %} {% info_block warningBox "Improved version of Dynatrace" %} We're going to release a refactored version of the Dynatrace integration. This version will be more robust and future-proof. For most projects, we recommend waiting for the new version. {% endinfo_block %} We are delighted to announce our newest integration - Dynatrace with Log Forwarding and Metrics Streaming from Spryker PaaS+! This integration is a key step in our journey to support more monitoring platforms compatible with Open Telemetry. This integration significantly enhances our current monitoring capabilities by extending the coverage of metrics and logs across crucial services such as Amazon ECS, RDS, OpenSearch Service, ElastiCache (Redis), PHP Exceptions, and RabbitMQ. Previously, the scope of these services was more limited, but with this enhancement, a broader and more precise range of metrics for tracking, debugging, and optimization is achieved. These monitoring improvements will also be available in New Relic and CloudWatch at no additional cost. This feature is ideal for customer DevOps/SREs seeking enhanced, flexible monitoring solutions. **Business benefits**:
Until now, New Relic was the sole option for aggregating logs and metrics. This integration offers customers the flexibility to connect and integrate their Dynatrace account to Spryker PaaS+, thus enhancing observability and cloud extensibility. Key features of this integration include the following: - Log forwarding: Facilitates forwarding of logs from Spryker Cloud services to Dynatrace, covering services like Amazon RDS, ECS, Redis, RabbitMQ, and OpenSearch. - Metric streaming: Streams performance metrics like CPU usage, memory, network latency, and error rates to Dynatrace, offering real-time insights. - Unified Observability Platform: Offers a centralized platform for all monitoring needs, compatible with various third-party platforms. - Efficient data processing: Ensures immediate forwarding of logs and metrics, with frequent data transmission for up-to-date monitoring. - Spryker support 24/7: Designed to work seamlessly with existing monitoring solutions, Spryker will keep watching over for you 24/7, regardless of the monitoring platform you use. - Scalability and adaptability: Can handle varying data volumes and peaks, with 24 hours of retention in case of unavailability. ### Technical prerequisites - Only available for Spryker Cloud customers. - You need a self-managed Dynatrace account, and you have to provide the necessary Endpoints to Spryker. ## ![acp](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_App+Orchestration+Platform_128.png) Improved performance, stability, and scalability {% include badge.html type="improvement" %} Adding third-party integrations via apps to your existing SCCOS solution has become easier with the App Composition Platform (ACP). Get in touch with us to get ACP enabled faster and take advantage of ACP's steadily growing number of no and low-code apps. **Business benefit**:
Simplified and faster enablement of ACP for SCCOS, as well as improved scalability, performance, and data security of the entire platform. ### Documentation [ACP overview](/docs/acp/user/intro-to-acp/acp-overview.html) ### Technical prerequisites [Install the ACP catalog](/docs/dg/dev/acp/app-composition-platform-installation.html) ## ![acp](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_App+Orchestration+Platform_128.png) Vertex app {% include badge.html type="feature" %} Staying up-to-date with ever-changing tax rules and rates can require a lot of resources. Spryker, through the Vertex integration, offers a means for businesses to automate tax calculation and centralize sales taxes on their transactions. **Business benefits**: - Comply with tax frameworks anywhere you do business. Let Vertex take care of tax management with a seamless and easy-to-use solution that meets the needs across Tax, IT, and Finance teams. - Free up valuable resources for other operations as it stays compliant and up to date with the tax regulations of your markets. - Automate tax processes and improve business agility by easily validating business tax at check-out and issuing tax-compliant invoices at the point of sale. ### Documentation [Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/vertex.html) ### Technical prerequisites - [Install ACP](/docs/acp/user/app-composition-platform-installation.html) - [Install Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/integrate-vertex.html) ## ![acp](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_App+Orchestration+Platform_128.png) Algolia app {% include badge.html type="improvement" %} Build an efficient path to purchase for your buyers with Algolia search, an innovative search and navigation solution that empowers your customers to quickly find the products they want. With our powerful and flexible implementation, headless or with search components on your storefront, you can easily integrate search capabilities into your storefront, streamlining the customer journey and increasing conversions. **Business benefits**: - Easily bring search into your storefront with our implementation, headless or with frontend search components, and enable customers to get to what matters faster. - With the latest feature addition, you can now use the search components to display Algolia search results and support your users with search suggestions. ### Documentation [Algolia](/docs/pbc/all/search/latest/base-shop/third-party-integrations/algolia/algolia.html) ### Technical prerequisites [Integrate Algolia](/docs/pbc/all/search/latest/base-shop/third-party-integrations/algolia/integrate-algolia.html) ## ![code-upgrader](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/code-upgrader.png) Autointegration of code releases {% include badge.html type="improvement" %} In addition to updating Spryker packages in your repository, with this release, Spryker Code Upgrader starts integrating plugins, settinh configurations keys, and adding new translations and similar elements to your project code. Now engineers don't have to figure out and manually apply code changes to activate new features. **Business benefit**:
Reduce the engineering time needed to integrate a Spryker module release into your project. ### Documentation [Integrating code releases](/docs/ca/devscu/integrating-code-releases/integrating-code-releases.html) ### Technical prerequisites Connect to [Spryker Code Upgrader](/docs/ca/devscu/spryker-code-upgrader.html) service to receive security updates semi-automatically. ## ![code-upgrader](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/code-upgrader.png) Security upgrades {% include badge.html type="improvement" %} Receive security releases before any other releases offered by Spryker Code Upgrader. The Upgrader prioritizes security releases, ensuring a timely application of critical security fixes. **Business benefit**:
Reduce the security risks from running outdated software by taking security updates before other updates. ### Documentation [Integrating security releases](/docs/ca/devscu/integrating-code-releases/integrating-security-releases.html) ### Technical prerequisites Connect to [Spryker Code Upgrader](/docs/ca/devscu/spryker-code-upgrader.html) service to receive security updates semi-automatically. ## ![code-upgrader](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/code-upgrader.png) Upgradability Evaluator improvements {% include badge.html type="improvement" %} This update offers notifications about critical security issues and vulnerabilities in Spryker and third-party components based on known vulnerability databases from NPM and Composer ecosystems. These improvements enhance the security monitoring and upgrade process. This update is complementary to the [Security Upgrades] improvement for Spryker Code Upgrader, but addresses all Spryker users. **Business benefit**:
Better awareness of security issues and vulnerabilities. ### Documentation - [Handling upgrade warnings](/docs/ca/devscu/integrating-code-releases/handling-upgrade-warnings.html) - [Spryker security checker](/docs/dg/dev/guidelines/keeping-a-project-upgradable/upgradability-guidelines/spryker-security-checker.html) - [NPM checker](/docs/dg/dev/guidelines/keeping-a-project-upgradable/upgradability-guidelines/npm-checker.html) - [Open-source vulnerabilities checker](/docs/dg/dev/guidelines/keeping-a-project-upgradable/upgradability-guidelines/open-source-vulnerabilities.html) ### Technical prerequisites Install and run [Upgrader compliance Evaluator](/docs/dg/dev/guidelines/keeping-a-project-upgradable/run-the-evaluator-tool.html) to detect security issues. ## ![composable-frontend](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_Composable+Storefront_128.png) Oryx Framework {% include badge.html type="improvement" %} Oryx Framework empowers developers to efficiently build composable frontends. Oryx provides a rich library of Oryx components, including a design system, allowing developers to rapidly create modern and visually appealing user interfaces. These components integrate with Spryker APIs by default, providing a seamless, decoupled experience for developers and end consumers. **Business benefit**:
Save time and effort with Oryx Framework. Spryker's purpose-built framework lets developers utilize fast, lightweight, and reactive components for storefronts and other frontends that quickly and dynamically display various devices. ### Learn more [Oryx in 90 seconds videos](https://www.youtube.com/playlist?list=PLJooqCSo73Sj9r_632NRtr-O0zuY7eHPb) ### Documentation [Oryx](/docs/dg/dev/frontend-development/latest/oryx/oryx.html) ### Technical prerequisites Oryx can be installed on your local machine and requires a Node.js or a compatible Javascript runtime and an npm runtime. For installation instructions, see [Set up Oryx](/docs/dg/dev/frontend-development/latest/oryx/getting-started/set-up-oryx.html). ## ![composable-frontend](https://spryker.s3.eu-central-1.amazonaws.com/docs/scos/user/intro-to-spryker/releases/release-notes/icon_Composable+Storefront_128.png) Composable Storefront: Additional foundation features - EA (early access) {% include badge.html type="improvement" %} Additional features are being released for Spryker's new upgradeable, decoupled frontend solution — Composable Storefront. This set of features provides essential components for commonplace purchase journeys. Spryker Composable Storefront is built using Spryker's Oryx framework, a reactive, fast, and lightweight framework. For more information about this Early Access product, contact your Spryker representative. **Business benefit**:
Provides commonplace features out-of-the-box for future-proof, agile, scalable, and upgradeable solutions for digital commerce business models. ### Learn more Composable Storefront is part of the Oryx framework. Oryx provides the features, and the presets for the various applications that you can create with Oryx, such as a Composable Storefront or Fulfillment App. ### Documentation [Oryx](/docs/dg/dev/frontend-development/latest/oryx/oryx.html) ### Technical prerequisites Oryx can be installed on your local machine and requires a Node.js or a compatible Javascript runtime and an npm runtime. See Set up Oryx for more information on the installation.

Project configuration for Vertex

Mon, 16 Mar 2026 08:55:32 +0000

This document describes the project configuration to consider when using Vertex for tax calculation. ## Adding country-specific fields to the address form Make sure that, on the Storefront, the address form has the required fields for each country. For example, the US store should have the **State** field, and the CA store should have the **Province** field. ## Sending additional data to Vertex By default, the following data is sent to Vertex for tax calculation: - Customer Shipping address - Product SKU - Shipping(delivery) method key - Warehouse address that also includes the Merchant warehouse address for a Marketplace model - Product SKUs - Product prices - Discounts - Shipping costs You can send additional data to Vertex, like a Customer Exemption Certificate, using plugins and the `taxMetadata` fields. You can add more data to request any specific information that's not available in Spryker by default. For example, this could be data from ERP, other systems, and customized Spryker instances. For the implementation details, see [Configure Vertex-specific metadata](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/configure-vertex-specific-metadata.html#2-implement-vertex-specific-metadata-extender-plugins). ## Additional configuration options for Vertex - You can configure the Vertex app for invoices to be saved in Vertex. However, we recommend to send invoice requests only for paid orders, as specified in [Integrate Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/integrate-vertex.html#8-optional-sending-tax-invoices-to-vertex-and-handling-refunds). The current implementation works asynchronously, so no response is saved in Spryker. - The default Spryker functionality uses tax rates to manage taxes. When using Vertex for tax determination, Vertex doesn't provide any tax rates to Spryker. To avoid confusion, we recommend removing the default Spryker tax rates. In the Back Office, you can delete them in **Administration** > **Tax Rates**. ## Logging and tracking Vertex issues If the Vertex app is down or taxes can't be calculated for other reasons, taxes are displayed as 0, letting customers place orders. For some orders, taxes might actually be 0, so there is no way to identify if there is an issue with tax calculation. In future, there will be a flag to identify and track these issues. ## Next steps [Verify Vertex connection](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/verify-vertex-connection.html)

Integrate Vertex

Mon, 16 Mar 2026 08:55:32 +0000

This document describes how to integrate [Vertex](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/vertex.html) into a Spryker shop. ## Prerequisites Before integrating Vertex, ensure the following prerequisites are met: - Make sure that your deployment pipeline executes database migrations. ## 1. Install the module Install the Vertex module using Composer: ```bash composer require spryker-eco/vertex ``` ## 2. Configure the module Add the following configuration to `config/Shared/config_default.php`: ```php use SprykerEco\Shared\Vertex\VertexConstants; $config[VertexConstants::IS_ACTIVE] = getenv('VERTEX_IS_ACTIVE'); $config[VertexConstants::CLIENT_ID] = getenv('VERTEX_CLIENT_ID'); $config[VertexConstants::CLIENT_SECRET] = getenv('VERTEX_CLIENT_SECRET'); $config[VertexConstants::SECURITY_URI] = getenv('VERTEX_SECURITY_URI'); $config[VertexConstants::TRANSACTION_CALLS_URI] = getenv('VERTEX_TRANSACTION_CALLS_URI'); // Optional: Tax ID Validator (requires Vertex Validator, previously known as Taxamo, see https://developer.vertexinc.com/vertex-e-commerce/docs/stand-alone-deployments) $config[VertexConstants::TAXAMO_API_URL] = getenv('TAXAMO_API_URL'); $config[VertexConstants::TAXAMO_TOKEN] = getenv('TAXAMO_TOKEN'); // Optional: Vendor Code $config[VertexConstants::VENDOR_CODE] = ''; ``` ### Required configuration constants | Constant | Description | |----------|-------------| | `IS_ACTIVE` | Enables or disables Vertex tax calculation. | | `CLIENT_ID` | OAuth client ID for the Vertex API. | | `CLIENT_SECRET` | OAuth client secret for the Vertex API. | | `SECURITY_URI` | Vertex OAuth security endpoint. | | `TRANSACTION_CALLS_URI` | Vertex transaction calls endpoint. | ### Optional configuration constants | Constant | Description | |----------|--------------------------------------------------------------------------------------------------------------------------------------------| | `TAXAMO_API_URL` | Vertex Validator API URL for tax ID validation. [Details](https://developer.vertexinc.com/vertex-e-commerce/docs/stand-alone-deployments). | | `TAXAMO_TOKEN` | Vertex Validator API authentication token. | | `VENDOR_CODE` | Vendor code for Vertex tax calculations. | | `DEFAULT_TAXPAYER_COMPANY_CODE` | Default taxpayer company code. | ## 3. Override feature flags The `isTaxIdValidatorEnabled`, `isTaxAssistEnabled`, and `isInvoicingEnabled` methods default to `false` and are not driven by constants. To enable them, override `src/Pyz/Zed/Vertex/VertexConfig.php`: ```php namespace Pyz\Zed\Vertex; use SprykerEco\Zed\Vertex\VertexConfig as SprykerEcoVertexConfig; class VertexConfig extends SprykerEcoVertexConfig { public function isTaxIdValidatorEnabled(): bool { return true; } public function isTaxAssistEnabled(): bool { return true; } public function isInvoicingEnabled(): bool { return true; } } ``` ### Config methods The following methods must be overridden in `src/Pyz/Zed/Vertex/VertexConfig.php` to enable the respective features: | Method | Default | Description | |--------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `isTaxIdValidatorEnabled()` | `false` | Enables tax ID validation via [Vertex Validator](https://developer.vertexinc.com/vertex-e-commerce/docs/stand-alone-deployments). Requires `TAXAMO_API_URL` and `TAXAMO_TOKEN` to be set. | | `isTaxAssistEnabled()` | `false` | Enables the tax assist feature. Return Assisted Parameters in the response that will provide more details about the calculation. The logs can be checked in the Vertex Dashboard. | | `isInvoicingEnabled()` | `false` | Enables invoicing functionality. Requires OMS plugins to be registered. See [Register OMS plugins](#register-oms-plugins). | | `getSellerCountryCode()` | `''` | Overrides the default seller country code (2-letter ISO code, for example, `US`). Defaults to the first country of the store. | | `getCustomerCountryCode()` | `''` | Overrides the default customer country code (applied only when no customer billing address is provided). Defaults to the first country of the store. | ## 4. Set up the database schema Install the database schema: ```bash vendor/bin/console propel:install ``` ## 5. Generate transfer objects Generate transfer objects for the module: ```bash vendor/bin/console transfer:generate ``` ## 6. Register plugins ### Register the tax calculation plugin Add the Vertex calculation plugin to `src/Pyz/Zed/Calculation/CalculationDependencyProvider.php`: ```php use SprykerEco\Zed\Vertex\Communication\Plugin\Calculation\VertexCalculationPlugin; protected function getQuoteCalculatorPluginStack(Container $container): array { return [ //... # Suggested plugins order is shown. new ItemDiscountAmountFullAggregatorPlugin(), # This plugin is replacing other tax calculation plugins in the stack and will use them as a fallback. # No other tax calculation plugins except for VertexCalculationPlugin should be present in the stack. new VertexCalculationPlugin(), new PriceToPayAggregatorPlugin(), //... ]; } protected function getOrderCalculatorPluginStack(Container $container): array { return [ //... # Suggested plugins order is shown. new ItemDiscountAmountFullAggregatorPlugin(), # This plugin is replacing other tax calculation plugins in the stack and will use them as a fallback. # No other tax calculation plugins except for VertexCalculationPlugin should be present in the stack. new VertexCalculationPlugin(), new PriceToPayAggregatorPlugin(), //... ]; } ``` #### Register Fallback Calculation Plugins Add order and quote Fallback Calculation Plugins to `src/Pyz/Zed/Vertex/VertexDependencyProvider.php`: ```php use Spryker\Zed\Calculation\Communication\Plugin\Calculator\ItemTaxAmountFullAggregatorPlugin; use Spryker\Zed\Calculation\Communication\Plugin\Calculator\PriceToPayAggregatorPlugin; use Spryker\Zed\Tax\Communication\Plugin\Calculator\TaxAmountAfterCancellationCalculatorPlugin; use Spryker\Zed\Tax\Communication\Plugin\Calculator\TaxAmountCalculatorPlugin; use Spryker\Zed\Tax\Communication\Plugin\Calculator\TaxRateAverageAggregatorPlugin; /** * {@inheritDoc} * * @return array<\Spryker\Zed\CalculationExtension\Dependency\Plugin\CalculationPluginInterface> */ protected function getFallbackQuoteCalculationPlugins(): array { return [ # These plugins will be called if Vertex configuration is missing or Vertex is disabled. # Please note that this list includes PriceToPayAggregatorPlugin - this plugin isn't a part of tax calculation logic but it's required by TaxRateAverageAggregatorPlugin. new TaxAmountCalculatorPlugin(), new ItemTaxAmountFullAggregatorPlugin(), new PriceToPayAggregatorPlugin(), new TaxRateAverageAggregatorPlugin(), ]; } /** * {@inheritDoc} * * @return array<\Spryker\Zed\CalculationExtension\Dependency\Plugin\CalculationPluginInterface> */ protected function getFallbackOrderCalculationPlugins(): array { return [ # These plugins will be called if Vertex configuration is missing or Vertex is disabled. # Please note that this list includes PriceToPayAggregatorPlugin - this plugin isn't a part of tax calculation logic but it's required by TaxAmountAfterCancellationCalculatorPlugin. new TaxAmountCalculatorPlugin(), new ItemTaxAmountFullAggregatorPlugin(), new PriceToPayAggregatorPlugin(), new TaxAmountAfterCancellationCalculatorPlugin(), ]; } ``` In general, `getFallbackQuoteCalculationPlugins()` and `getFallbackOrderCalculationPlugins()` methods should contain the tax calculation plugins, which are replaced by `VertexCalculationPlugin` in `\Pyz\Zed\Calculation\CalculationDependencyProvider`. The code snippet above is an example of such configuration based on the Spryker default tax calculation plugins. Tax calculation plugins moved: - from `getQuoteCalculatorPluginStack` method: `TaxAmountCalculatorPlugin`, `ItemTaxAmountFullAggregatorPlugin`, `PriceToPayAggregatorPlugin`, `TaxRateAverageAggregatorPlugin` - from `getOrderCalculatorPluginStack` method: `TaxAmountCalculatorPlugin`, `ItemTaxAmountFullAggregatorPlugin`, `PriceToPayAggregatorPlugin`, `TaxAmountAfterCancellationCalculatorPlugin` {% info_block infoBox "Fallback behavior" %} There are three different failure scenarios where `VertexCalculationPlugin` might need to use a fallback logic: 1. Vertex isn't connected: fallback plugins defined in `getFallbackQuoteCalculationPlugins()` and `getFallbackOrderCalculationPlugins()` will be used to calculate taxes. 2. Vertex is disabled: fallback plugins defined in `getFallbackQuoteCalculationPlugins()` and `getFallbackOrderCalculationPlugins()` will be used to calculate taxes. 3. Vertex is not responding or is responding with an error: tax value will be set to zero, and the customer will be able to proceed with the checkout. {% endinfo_block %} ### Register CalculableObject and order expander plugins Add order and CalculableObject expander plugins to `src/Pyz/Zed/Vertex/VertexDependencyProvider.php`. The proposed plugins are examples, you can select which ones to register based on your requirements or create custom ones if needed. ```php use SprykerEco\Zed\Vertex\Communication\Plugin\Order\OrderCustomerWithVertexCodeExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Order\OrderExpensesWithVertexCodeExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Order\OrderItemProductOptionWithVertexCodeExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Order\OrderItemWithVertexSpecificFieldsExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Quote\CalculableObjectCustomerWithVertexCodeExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Quote\CalculableObjectExpensesWithVertexCodeExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Quote\CalculableObjectItemProductOptionWithVertexCodeExpanderPlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Quote\CalculableObjectItemWithVertexSpecificFieldsExpanderPlugin; protected function getCalculableObjectVertexExpanderPlugins(): array { return [ // ... other plugins new CalculableObjectCustomerWithVertexCodeExpanderPlugin(), new CalculableObjectExpensesWithVertexCodeExpanderPlugin(), new CalculableObjectItemProductOptionWithVertexCodeExpanderPlugin(), new CalculableObjectItemWithVertexSpecificFieldsExpanderPlugin(), ]; } protected function getOrderVertexExpanderPlugins(): array { return [ // ... other plugins new OrderCustomerWithVertexCodeExpanderPlugin(), new OrderExpensesWithVertexCodeExpanderPlugin(), new OrderItemProductOptionWithVertexCodeExpanderPlugin(), new OrderItemWithVertexSpecificFieldsExpanderPlugin(), ]; } ``` ## 7. Configure the Shop Application dependency provider Add the following code to `src/Pyz/Yves/ShopApplication/ShopApplicationDependencyProvider.php`: ```php namespace Pyz\Yves\ShopApplication; use SprykerShop\Yves\ShopApplication\ShopApplicationDependencyProvider as SprykerShopApplicationDependencyProvider; use SprykerShop\Yves\CartPage\Widget\CartSummaryHideTaxAmountWidget; class ShopApplicationDependencyProvider extends SprykerShopApplicationDependencyProvider { /** * @phpstan-return array> * * @return array */ protected function getGlobalWidgets(): array { return [ //... # This widget is replacing Spryker default tax display in cart summary page with text stating that tax amount will be calculated during checkout process. CartSummaryHideTaxAmountWidget::class, ]; } } ``` If you have custom Yves templates or make your own Frontend, add `CartSummaryHideTaxAmountWidget` to your template. The core template is located at `SprykerShop/Yves/CartPage/Theme/default/components/molecules/cart-summary/cart-summary.twig`. Here is an example with `CartSummaryHideTaxAmountWidget`: ```html {% raw %}

{{ 'cart.total.tax_total' | trans }} {% widget 'CartSummaryHideTaxAmountWidget' args [data.cart] only %} {% nowidget %} {{ data.cart.totals.taxTotal.amount | money(true, data.cart.currency.code) }} {% endwidget %}

{% endraw %} ``` ## 8. Optional: Sending tax invoices to Vertex and handling refunds Configure payment `config/Zed/oms/{your_payment_oms}.xml`as in the following example: ```xml paid tax invoice submitted submit tax invoice tax invoice submitted ``` ### Register OMS plugins {% info_block infoBox "Optional" %} This step is required only if you want to use invoicing functionality. Make sure `isInvoicingEnabled()` is set to `true` in `VertexConfig.php`. {% endinfo_block %} Add OMS plugins to `src/Pyz/Zed/Oms/OmsDependencyProvider.php`: ```php use SprykerEco\Zed\Vertex\Communication\Plugin\Oms\Command\VertexSubmitPaymentTaxInvoicePlugin; use SprykerEco\Zed\Vertex\Communication\Plugin\Oms\VertexOrderRefundedEventListenerPlugin; # This configuration is necessary for Invoice functionality protected function extendCommandPlugins(Container $container): Container { $container->extend(self::COMMAND_PLUGINS, function (CommandCollectionInterface $commandCollection) { // ... other command plugins $commandCollection->add(new VertexSubmitPaymentTaxInvoicePlugin(), 'Vertex/SubmitPaymentTaxInvoice'); return $commandCollection; }); return $container; } # This configuration is necessary for Refund functionality protected function getOmsEventTriggeredListenerPlugins(Container $container): array { return [ // ... other plugins new VertexOrderRefundedEventListenerPlugin(), ]; } ``` This configuration of `getOmsEventTriggeredListenerPlugins` method is required to ensure that the correct tax amount will be used during the refund process. {% info_block infoBox "OMS configuration requirement" %} The refund functionality will only work if the OMS event is called `refund`. {% endinfo_block %} ## Next step [Configure Vertex-specific metadata](/docs/pbc/all/tax-management/latest/base-shop/third-party-integrations/vertex/install-vertex/configure-vertex-specific-metadata.html)