Into the checkout: building a Shopify Payments App for Paypercut

The most guarded screen on Shopify

Every Shopify app can change a storefront. Very few are allowed to touch the payment step.

Paypercut is a European payments platform built in Sofia. It gives merchants one checkout for cards, digital wallets and several Buy Now, Pay Later providers, with payouts in local currency to the bank account they already have. Their pitch is simple: sell across Europe without rebuilding your checkout for every market.

For many European merchants, “your checkout” means Shopify. So Paypercut needed to appear where it matters most: in the payment list on Shopify's own checkout, next to every other way to pay.

That is harder than it sounds. Shopify does not let payment providers inject scripts into checkout. A provider has to become a Shopify Payments Partner, build a dedicated Payments App on Shopify's Payments Apps API, pass a review that is far stricter than the regular App Store review, and then handle real money with no room for a lost or double-charged order.

Our mission was to build that app for Paypercut. A merchant should be able to install it, paste a key and take a test payment right away. A buyer should move from Shopify checkout to Paypercut and back without noticing the seam. And every payment, capture, void and refund should reach the right state in both systems, every time.

Here is how we built it, worked through Shopify's review, and launched on the Shopify App Store.

Part 1: the buyer's path, out to Paypercut and back

Leaving the checkout feels risky

Paypercut takes card details on its own hosted page, which keeps card data out of Shopify and the merchant's hands entirely. The catch is the handoff. Any redirect away from a checkout is a moment where buyers hesitate, and any hiccup on the way back can leave an order paid but unconfirmed.

An offsite payments extension with a clean round trip

We built Paypercut as an offsite payments extension. At checkout, buyers in 30 EEA countries see “Pay by card” with Visa and Mastercard marks, right in Shopify's native payment list. The demo at the top of this page walks through the full trip.

• The handoff: when the buyer clicks “Pay now”, Shopify calls our app, and our app creates a Paypercut hosted checkout session for that exact payment. The buyer's email and language come along, so the Paypercut page opens prefilled and in their language.
• The payment: the buyer enters their card on Paypercut's page, with 3-D Secure where the bank requires it.
• The return: Paypercut sends the buyer back to our app, which confirms the payment and tells Shopify to complete the order. The buyer lands on Shopify's own thank-you page.

The psychology: trust transfer. The buyer starts on a checkout they already trust, picks a payment method that looks native, and ends on that same checkout's confirmation page. The Paypercut step sits between two familiar screens, so the trust carries across it.

Part 2: the merchant's path, from install to first test payment

Payment setup is where merchants give up

Most payment integrations ask merchants to copy keys, configure webhooks and toggle settings across two dashboards. Every extra step is a chance to paste the wrong thing and quit.

Two keys, clear errors, no webhook setup

The merchant's whole setup happens on one page:

• Sandbox and live keys, side by side. Merchants can start with a sandbox key while Paypercut verifies their business, then add the live key later. Shopify's own test mode decides which key each payment uses, so merchants test exactly the way Shopify teaches them to.
• Errors that say what to do. We wrote a specific message for every mistake we could anticipate: pasting a publishable key instead of a secret one, putting a live key in the sandbox field, using an expired key, or a key without payment permissions. Each one tells the merchant what went wrong and links to the right place in the Paypercut dashboard.
• A status banner that explains the gaps. With only a sandbox key, the page says live payments will be declined until the live key is added. With only a live key, it says test-mode payments will fail.
• No webhook configuration. When a key is saved, the app registers its own Paypercut webhook endpoint for that mode in the background.

The psychology: recognition over recall. The merchant does not need to remember which key is which. The fields say “Starts with sk_test_” and “Starts with sk_live_”, and the error names the exact key they pasted.

Part 3: the engine room, getting money right

A payment that is half-confirmed is worse than a payment that fails.

Two systems must agree on every cent

Shopify and Paypercut each keep their own record of a payment. Networks drop requests, buyers close tabs, and Shopify retries calls it is not sure about. The app has to keep both records in step without ever charging twice or leaving an order stuck.

Idempotent sessions and two ways to confirm

• One Shopify session, one Paypercut session. Shopify's session ID is the idempotency key for the Paypercut checkout. If Shopify asks twice, Paypercut answers with the same session instead of creating a second one.
• Confirm twice, resolve once. When the buyer returns, the app asks Paypercut for the payment's status and retries while it is still pending. In parallel, Paypercut sends a signed webhook. Every webhook is verified, deduplicated and claimed atomically, so whichever confirmation arrives first resolves the payment and the second one changes nothing.
• Captures, voids and refunds from Shopify admin. Each operation has its own state machine (not processed, processing, processed), so a retried refund request can never refund twice. Merchants can also take payments as authorisations and capture later; the app passes Paypercut's authorisation expiry to Shopify, so the order shows when the hold runs out.
• Mutual TLS on the payment endpoints. Shopify presents a client certificate on every payment call, and only those endpoints are exposed behind certificate verification.

Part 4: through review and into production

Shopify's payments review

Payments Apps go through a dedicated review, and it is detailed. The feedback we worked through included clearing a merchant's credentials when they uninstall, sending merchants straight back to Paypercut's settings in Shopify after they save their keys, and making every error message clear enough to act on. After the resubmission, Paypercut went live on the Shopify App Store on 10 August 2026.

Built to run inside a payments company

Paypercut is a regulated payments business, so the app had to fit their platform, not the other way around. We worked alongside Paypercut's own engineers, who run the Kubernetes infrastructure the app deploys to.

• Release pipeline: merges deploy to a dev environment, and tagged releases go through staging to production. The Shopify extension ships through its own workflow from the same tag.
• Security hardening: gateway errors are logged, never shown to buyers. The key form gives the same answer for an invalid key and a key that belongs to another shop, so it cannot be used to probe keys. Container images are scanned and fixed before release.
• Shopify's newest rules: when Shopify introduced expiring offline access tokens, the app moved to refreshing tokens before they expire, so no payment call fails on a stale token.

A new payment method, native to Shopify

Paypercut wanted European merchants on Shopify to add them the way they add any other payment provider. That is now how it works.

1. Native at checkout. “Pay by card” sits in Shopify's own payment list in 30 EEA countries, with a round trip to Paypercut's hosted page that buyers barely notice.
2. Self-serve onboarding. Merchants paste a key and take test payments without a call, a developer or any webhook setup.
3. Every operation, exactly once. Sales, authorisations, captures, voids and refunds stay in step between Shopify and Paypercut, even when requests are retried.
4. Approved and live. Paypercut passed Shopify's payments review and is listed on the Shopify App Store.

By the numbers

30

EEA countries where buyers see Paypercut at checkout

5

payment operations: sale, authorise, capture, void and refund

2

keys, sandbox and live, switched by Shopify's own test mode

15

onboarding errors, each with a specific message and next step

0

webhooks for the merchant to configure by hand

Aug 10

2026: live on the Shopify App Store

The best payment integration is the one nobody thinks about. The buyer pays, the merchant ships, and the money is where it should be.

How it is built

A Shopify Payments App on the Payments Apps API, shipped as an offsite payments extension. Node and Remix for the app, Polaris for the merchant settings, mutual TLS on the payment endpoints, signed and deduplicated webhooks, and per-operation state machines for capture, void and refund. Deployed on Paypercut's Kubernetes platform through a dev, staging and production pipeline.