SAP- Open Payment Framework

This guide explains how, as a payever merchant, you can connect payever to your SAP Commerce Cloud, Open Payment Framework (OPF) tenant using the ready-made payever Postman Collection published by SAP.

Step 1: Register an account

Create your free payever account here, or log in if case you already have one. 

Step 2: Configure payment options

In order to configure your payment options, first open the Checkout app. To do this, either click on the Checkout symbol under Business Apps or click on the Manage or Open button on the Checkout section.  

You can find the Payment options tab in the navigation bar on the left. 

Then click on + Add.

Now a list of different payment methods appears, from which you can select as needed. To do this, click on Install.

Once you have installed the payment channel, click on Open and a new page will open, the structure of which will vary depending on the payment method chosen.

With the payment methods Credit Card, Direct Debit and PayPal just click the Connect button and you will be forwarded to the respective payment provider. There you connect your existing account or create a new one. 

For the payment methods Openbank Pay Installments, Openbank Pay BNPL and Openbank Pay Lending/Financing, enter the access data you have received from Openbank Pay and then click Connect. If you have not been in touch with Openbank Pay before, please contact support@payever.de.

The access data may vary depending on the payment method and can range from a single numeric or alphanumeric code to up to four different codes.

Regardless of the payment method, please make sure that you always enter your access data in the Default tab.

After you have connected the payment methods, you can make changes to the settings of the specific payment method. Please refer to our documentation for the specific payment method for more information, which you can find here. 

Step 3: Configure channels

After having registered on payever and having installed the desired payment options select the Channels tab in the Checkout App.

Click + Add.

Select API and click on Install.

Now you need to click Open so that you can generate the API keys in the next step.

1. Click on API keys and Add

2. Give the API key any name you like and click Create.

3. Now click the + icon.

4. You will now see the information you'll need to enter later (Client ID, Client Secret, and Business UUID). Please copy these to your clipboard.

Once done, click Close in the upper right corner.

Step 4: Integrate payever in SAP- Open Payment Framework

4.1 Overview

The Open Payment Framework lets you orchestrate payment service providers (PSPs) from within SAP Commerce Cloud. payever is integrated as a payment integration inside your OPF tenant. Rather than configuring every mapping by hand in the OPF workbench, SAP provides a Postman Collection that programmatically creates and configures the payever integration against your tenant's Merchant API.

The integration is built around payever's Payments V3 REST API. The OPF tenant calls payever's create payment endpoint to authorize a transaction on a Hosted Payment Page, and then performs follow-up operations (capture, refund, reversal) and consumes payever notifications.

The collection demonstrates the following capabilities:

• Authorize a payment using payever's Hosted Payment Page (full-page redirect)
• Settlement (capture)
• Refund
• Reversal (authorization reversal)

It also configures the supporting pieces required for a working integration: an OAuth 2.0 outbound authentication, an HMAC signature verification for inbound notifications, and the account-level capture behaviour.

4.2 What You Will Need

To complete the integration you need the two configuration files from SAP's payever PAYMENT-PAGE sample:

You also need access to:

• An OPF workbench / cockpit for your licensed SAP Commerce Cloud, Open Payment Framework tenant.
• Postman (desktop or web), to import and run the collection.
• A set of payever API credentials (Client ID and Client Secret). For the sandbox these are published; for production they are issued to your payever account.

4.3 Sandbox vs. Production

You can run the collection against either the payever open sandbox or production.

NOTE: The sandbox is monitored and supported Monday to Friday, 8am to 6pm CET. You can call it outside these hours, but support requests are handled only during this window. For assistance contact support@payever.de.

4.4 Supported Payment Methods

The following ecommerce payment methods (and their issuers) are available via the payever API and can be configured through the OPF collection. Point-of-sale (POS) methods are intentionally excluded - this collection covers ecommerce only. For the complete, always-current list, see the payever payment methods reference.

NOTE: Availability varies by country and by your contract with payever. For the conditions of each method (amount ranges, currency, country, address rules), refer to the payever payments documentation.

4.5 Integration Overview

At a high level, connecting payever to OPF involves four steps, each covered below:

1. Create a payment integration in the OPF workbench, which gives you an integration ID and a configuration ID.
2. Get your credentials - an OPF bearer token plus your payever Client ID and Client Secret.
3. Configure the Postman environment file with your tenant URL, IDs, and payever values.
4. Import and run the collection to provision the payever integration on your tenant, then validate it.

NOTE: The samples in SAP's repository are reference implementations and are not officially supported by SAP or payever. Always test thoroughly in your OPF tenant before going live.

Step 1: Create a Payment Integration

The first step is to create a payever payment integration in your OPF workbench. This produces the two identifiers the Postman Collection needs to target the right account: the integration ID and the configuration ID.

For the authoritative, UI-level walkthrough, refer to SAP's Creating Payment Integration documentation. The steps below summarize the process from a payever merchant's perspective.

Steps in the OPF Workbench

1. Open the OPF workbench for your tenant, for example, https://<your-tenant>.commerce.<region>.context.cloud.sap/opf-workbench.
2. Create a new payment integration for payever.
3. Within that integration, create a payment configuration.
4. Open the Configuration Details page. In the top-left of this page you will find the two IDs you need.

Identifiers You Obtain

You will set these two values in the Postman environment file in Step 3.

Site Assignment

Each payment integration must be assigned to a site (base store) in your SAP Commerce Cloud tenant, so that the integration is offered at that storefront's checkout. You set this in the integration's General Information: open the integration, click the edit (pencil) icon on the General Information card, and set the Site Assignment field (for example, electronics-spa).

The same card also shows the Notification URL that payever calls for status updates, and lets you adjust the Authorization Time-out Days and Capture & Refund Attempts.

Merchant ID (Business UUID)

payever identifies your store with a Business UUID. In OPF this is entered as the Merchant ID of the integration.

NOTE: The Business UUID is also referenced by payever's List Payment Options endpoint, so keep it available.

Add the payever Domain to the Allowlist

Before the integration can call payever, the payever API domain must be added to your tenant's domain allowlist in the OPF workbench. For instructions, see SAP's Adding Tenant-specific Domain to Allowlist documentation.

Add the domain that matches the environment you intend to use:

NOTE: If you skip this step, the Authorization request will be unable to reach payever's create payment endpoint, and authorization attempts will fail.

Step 2: Get Your Credentials

Two kinds of credentials are required: an OPF bearer token (to call your tenant's Merchant API) and your payever API keys (so the integration can call payever).

OPF Bearer Token

The collection authenticates against your OPF tenant with a bearer token passed in the Authorization header of every request. This token is not a payever credential. It is an OAuth 2.0 access token (JWT) for your own OPF tenant API, issued to an "external application" that you create in the OPF workbench using the client credentials grant.

1. Create an external application

In the OPF workbench, create an External Application. OPF generates a client ID and client secret for it. These are OPF credentials and are separate from your payever Client ID/Secret. For the UI steps, see SAP's Creating an External Application documentation.

2. Request an access token

Exchange the external application's credentials for an access token using the client_credentials grant against your tenant's token endpoint. For the exact endpoint of your landscape, see SAP's Making Authorized API Calls documentation.

The response contains the JWT in the access_token field:

curl -X POST 'https://<your-opf-tenant>/oauth/token' \
 -H 'Content-Type: application/x-www-form-urlencoded' \
 -u '<external_app_client_id>:<external_app_client_secret>' \
 -d 'grant_type=client_credentials'

{
 "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
 "token_type": "bearer",
 "expires_in": 3600
}

3. Set the token variable

Copy the access_token value into the token variable in the Postman environment, prefixed with the word Bearer and a space. The collection sends the header literally as Authorization: {{token}}, so the scheme must be part of the variable value:

token = Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...

IMPORTANT: The token expires (see expires_in, typically about one hour). When requests start returning 401, request a fresh token and update the token variable. An empty or expired token is the most common cause of 401 Unauthorized on every request.

payever API Keys

The integration calls payever using OAuth 2.0, so you need a payever Client ID and Client Secret.

For more detail on payever authentication, see Authentication.

Step 3: Configure the Postman Environment

Before importing the collection, edit environment_configuration.json so that every request runs against your OPF tenant and your payever account. The environment file is split into common OPF variables and payever-specific variables, plus the outbound OAuth 2.0 values used by the authentication mapping.

Common (OPF) Variables

payever-Specific Variables

NOTE: The Business UUID (Merchant ID, e.g. payever for the sandbox) is configured on the integration itself in the OPF workbench, as described in Step 1. If you reference it as a Postman variable (merchantId), add it to the environment file as well.

Outbound OAuth 2.0 Variables

These values populate the OAuth 2.0 authentication that OPF uses when calling payever. They are referenced by the Oauth2 request in the collection.

IMPORTANT: In the unedited sample file, the outbound client ID and secret contain placeholder text (Payever oAuth2 Auth_clientId / Payever oAuth2 Auth_clientSecret). Replace these with your real payever Client ID and Client Secret, otherwise the OAuth token request to payever will fail.

Account Behaviour Variables

These tune how the payever account/configuration behaves and are applied by the Account Patch and Account Group Patch requests.

Example Environment File

After editing, your environment file should resemble the following. Replace every <...> placeholder with your own values.

{
 "name": "payever",
 "values": [
 { "key": "token", "value": "Bearer <opf_access_token_jwt>", "enabled": true },
 { "key": "rootUrl", "value": "https://<your-tenant>.commerce.stage.context.cloud.sap", "enabled": true },
 { "key": "service", "value": "opf", "enabled": true },
 { "key": "accountGroupId", "value": "<integration_id>", "enabled": true },
 { "key": "accountId", "value": "<configuration_id>", "enabled": true },
 { "key": "clientId", "value": "<payever_client_id>", "enabled": true },
 { "key": "secret", "value": "<payever_client_secret>", "enabled": true },
 { "key": "apiDomain", "value": "proxy.staging.devpayever.com", "enabled": true },
 { "key": "apiVersion", "value": "v3", "enabled": true },
 { "key": "paymentMethod", "value": "santander_installment", "enabled": true },
 { "key": "authentication_outbound_oauth2_token_url_export_1080", "value": "https://proxy.staging.devpayever.com/oauth/v2/token", "enabled": true },
 { "key": "authentication_outbound_oauth2_client_id_export_1080", "value": "<payever_client_id>", "enabled": true },
 { "key": "authentication_outbound_oauth2_client_secret_export_1080", "value": "<payever_client_secret>", "enabled": true },
 { "key": "authentication_outbound_oauth2_use_basic_auth_export_1080", "value": "false", "enabled": true },
 { "key": "capturePattern", "value": "PARTIAL_CAPTURE", "enabled": true },
 { "key": "enableOverCapture", "value": "false", "enabled": true },
 { "key": "enableCaptureReAuth", "value": "false", "enabled": true },
 { "key": "authorizationTimeoutDays", "value": "7", "enabled": true }
 ],
 "_postman_variable_scope": "environment"
}

Root URL

The rootUrl is the base URL of your OPF tenant - without any path. Derive it from your workbench / cockpit URL by removing the trailing path.

For example, if your workbench URL is:

https://opf-iss-d0.uis.commerce.stage.context.cloud.sap/opf-workbench

then the base URL is:

https://opf-iss-d0.uis.commerce.stage.context.cloud.sap

NOTE: Do not include a trailing slash. The collection appends the /{{service}}/merchant/... path itself.

Step 4: Import and Run the Collection

With the environment file prepared, you can import both files into Postman and run the requests to provision the payever integration on your OPF tenant.

Import the Files

1. Import environment_configuration.json as a Postman Environment.
2. Import mapping_configuration.json as a Postman Collection.
3. Select the imported environment in the top-right environment selector before running anything. If no environment is selected, the {{...}} variables resolve to empty strings and the requests will fail.

For the official import procedure into an OPF tenant, see SAP's Importing a Postman Collection documentation.

How the Collection Is Built

Every request targets your tenant's Merchant API and authenticates with the Authorization: {{token}} header. The base path is:

{{rootUrl}}/{{service}}/merchant/...

A collection-level pre-request script removes the /{{service}} segment automatically if you leave the service variable empty:

let url = pm.request.url.toString();
if (pm.environment.get("service") == null || pm.environment.get("service") === "") {
 let updateUrl = url.replace("/{{service}}", "");
 pm.request.url = updateUrl;
}

The collection is organized into the following folders.

Recommended Run Order

Run the requests so that dependencies exist before they are referenced:

1. Variable - create all variables first; the mappings depend on them.
2. Authentications - create the OAuth 2.0 and HMAC authentications.
3. AccountGroup and Account - apply the integration and configuration settings.
4. Authorization, Settlement, Refund, Authorization_reversal, Notification - create the request mappings.

You can run requests individually, or use the Postman Collection Runner to execute the whole collection in order against the selected environment.

4.6 Example: Authorization Mapping

The Authorization request maps an OPF authorize call to payever's create-payment endpoint. Its outbound mapping looks like this:

{
 "pattern": "FULL_PAGE",
 "requestType": "AUTHORIZATION",
 "remoteApiOutboundMappings": [
 {
 "method": "POST",
 "url": "https://${vars.apiDomain}/api/${vars.apiVersion}/payment",
 "requestContentType": "application/json",
 "authenticationIds": ["{{authentication_outbound_oauth2_1080}}"],
 "requestExample": {
 "channel": { "name": "api", "type": "ecommerce", "source": "1.0.0" },
 "purchase": { "amount": 140, "currency": "EUR", "delivery_fee": 10 },
 "reference": "900001291100",
 "payment_method": "${vars.paymentMethod}",
 "cart": [
 { "identifier": "123", "name": "Some Item", "total_amount": 100, "unit_price": 50, "tax_rate": 0, "quantity": 2, "sku": "123" }
 ]
 }
 }
 ]
}

The request body forwarded to payever follows the create payment schema, so any field documented there can be added to the mapping. For the full list of mappable parameters, refer to the Payments V3 API.

4.7 Test Requirements

A payment method is only displayed/available when the order satisfies that method's eligibility rules. These rules differ per method, and each can define its own:

• Amount range - a minimum and maximum transaction amount.
• Billing/shipping address restrictions - for example, billing and shipping address must match.
• Country restriction - the method is offered only in specific countries.
• Currency restriction - the method supports only specific currencies.

If a method does not appear during a test, the most common cause is an order that falls outside one of these rules. For the exact conditions of each method, refer to the payever payments documentation.

For sandbox testing, use the payever test credentials and test data to simulate transactions.

4.8 Troubleshooting

For tenant-side diagnostics, use SAP's Open Payment Framework Logging. For payever-side errors, see the payever status codes and errors reference.

4.9 Go Live

Before switching to production:

1. Run end-to-end tests for each payment method you intend to offer, using the sandbox apiDomain and the published test credentials.
2. Switch apiDomain to proxy.payever.org and the OAuth token URL to the production host.
3. Replace the sandbox payever keys with your production Client ID and Client Secret.
4. Add proxy.payever.org to the tenant allowlist (see Step 1).
5. Update the Merchant ID on the integration to your production Business UUID.

NOTE: The staging and live environments are separate systems with separate credentials. Sandbox keys will not work against production and vice versa.

4.10 Configuring Individual Payment Methods

payever offers many payment methods (see Supported Payment Methods (point 4.4)). In OPF, a payment integration of type Payment Method maps to a single payever payment method. To offer several payever methods at your checkout, create a separate payever integration for each method (for example Payever-01, Payever-02, Payever-03, and so on). Each integration carries its own payment_method value.

You can set the payment method either through the Postman collection (the paymentMethod variable, see Step 3) or directly in the OPF workbench UI. The workbench steps are described below.

1. Select the payment integration

From Payment Integrations, open the payever integration you want to configure. To add a method, click Create to add a new payever integration first.

2. Show details

On the integration's Configuration card, click Show Details to open the configuration's field mappings. You can also Export to Postman Collection from here.

3. Edit the Authorization request

In the Configuration screen, under Payment Processing, click Edit on the Authorization card.

4. Set the payment method

In the Authorization field mappings, find the payment_method field, set its mapping type to Manual input, and enter the payever method code (for example, paypal). Use the codes listed in Supported Payment Methods (point 4.4). Click Save.

5. Discover available fields with Smart Fields

If you are unsure which field names are available or what values they accept, click Open Smartfield Details in the Mapping section to browse all smart fields. You can also use Generate fields to map from request example to populate the mapping from a sample request body.

NOTE: Repeat these steps for each payever payment method you want to offer, creating one payever integration per method.

Once the configuration has been completed correctly, you are finished, and the checkout should look like this in your frontend shop.

Still have questions or facing issues?

You can reach our free support Monday through Friday between 8 a.m. and 6 p.m. at support@payever.de 

Please include in your message, which shop or business your request refers to, and the email address you are registered with us. Please also describe as precisely as possible which error message or issue you noticed and at which step it occurred. This will help us review and process your request more quickly. You are also welcome to send us screenshots or any other relevant information that may help us better understand the issue.