Accepting international payments
Payment by a foreign card in the buyer’s currency, clear behaviour on a decline, and reconciliation of receipts. Starts with a free review.
An integration for a website or online store is done when data flows both ways and survives updates. A key appearing in the admin panel and a test payment going through doesn't mean it's finished. The gap usually shows up in week three: the payment cleared, but the order is still marked unpaid; the shipment was created, but the tracking number never reached the customer. The work here is grouped by what's being passed along: money, parcels, products sent to marketplaces, customer notifications, documents for accounting. That's five groups, and each breaks in its own places. So we test the whole scenario, from the click on the site to the record in your accounting system, instead of checking that the connection exists.
We draw a map: which systems exist, what data moves between them, in which direction and on which event.
We connect APIs, webhooks or file exchange and map the fields so data arrives in the right form.
We test on real examples, and exchange errors go to a log so they are seen and fixed.
Possibilities depend on the systems we connect: if they have no API or export, we look for a workaround or say plainly where the limit is.
Payment by a foreign card in the buyer’s currency, clear behaviour on a decline, and reconciliation of receipts. Starts with a free review.
Connecting Checkbox to the online store: check by payment event, duplicate protection, return check, closing shift, offline mode. The term is 8–15 working days.
We add card payments, bank transfer and pay-in-installments to your store checkout, and use measurements to show how many payment methods you actually need.
Connecting your store to Epicentr Marketplace: XML by link, category and attribute codes, prices and stock, orders via API. Free catalog review.
We connect Fondy to the site: card in the checkout, payment in several currencies, regular debits, returns from the admin. Screening is free.
A product feed for Merchant Center: identifiers, Product and Offer markup, matching prices and availability, and a review of disapprovals. Free catalog check.
Emails triggered by store events: abandoned cart, order status, back in stock. Plus deliverability and tracking tags so email revenue shows up in your reports.
Connecting Nova Poshta: branch and parcel locker at checkout, delivery cost, waybill and declaration printing from the admin. Checkout audit is free.
Notification of store events: order accepted, status changed, shipped with invoice number. Plus clean numbers and protection against resends.
Connecting Ukrposhta to the site: express and standard to the branch, courier, index directory, calculation in the basket, sending from the admin.
Exporting your catalog to Prom.ua via a feed, syncing stock and sending orders to your CRM. Or moving the catalog to your own domain. The review is free.
Feeds the catalog to the marketplace: XML-feed from the site database, category scheme, characteristics with parameters, site delivery. The check is free.
Kasta integration built around your store: a Rozetka-structure feed or the HUB API, stock, prices and order statuses. Free catalog review in 2–3 days.
Sending website forms and orders to KeyCRM: field mapping, lead source tracking, duplicate merging and a retry queue. A review of your lead flow is free.
LiqPay on your site: card payment at checkout, callbacks with signature checks, handling of interrupted payments and refunds from the admin. Takes 6–10 days.
Meest Express on your site: branch selection from a list, directory updates, shipping cost calculation and a tracking number in the email. Free checkout review.
We connect monobank to your site: card payment at checkout, pay-in-installments with visible terms and separate order statuses. The checkout review is free.
Store-to-SalesDrive exchange built for your task: orders with UTM and delivery go to the CRM, status and waybill come back, stock syncs from YML. Free review.
Site sync with 1C or BAS: field mapping, a stable product key, scheduled price and stock updates, orders into the database, an error log. Free file review.
Every call is logged as a lead with its source and page and sent to your CRM, plus number substitution by channel and missed-call tracking. Free review first.
Integration where no ready-made module exists: third-party API research, an exchange contract, webhooks or polling, a retry queue and a log. Free API research.
Connecting WayForPay: card, Apple Pay, payment in instalments, callbacks with signature verification, agreed order statuses. Checkout check is free.
Every missing payment method means some orders never get completed. Connecting one isn't enough, though: the money has to arrive and automatically update the order status. Otherwise your manager still reconciles everything by hand, and the point is lost.
We'll review your situation in a free auditThe manager opens the carrier's account, copies the address, creates the shipment, goes back to the admin panel, and types in the tracking number. Twenty times a day. A shipping integration removes exactly this retyping, and the address errors that come with it.
The price changed on the site but not on the marketplace; an item sold out on the site, but orders keep coming in from there. Exports have to be automatic and two-way, or the marketplace becomes a source of cancellations instead of sales.
Orders in one place, products in another, stock in a third, and it all gets reconciled manually at the end of the day. An exchange with 1C, BAS, or a CRM removes double entry, but it requires deciding which system is the source of truth for each field.
We work out what has to happen from start to finish, beyond the question of what to connect: who initiates the exchange, which fields are passed, which system wins when data conflicts. Most mistakes are made here, before any code.
We build the exchange on test keys and a copy of the site. Real money and real shipments play no part in testing. We treat that as a hard requirement.
We run the full scenario several times, including the failure cases: a declined payment, an unavailable service, a wrong address. We check what the customer sees and what ends up in the logs.
We swap in the production keys, place a control order on the live site, and check that it reached accounting. Only after that do we sign the acceptance act.
A ready-made module covers the basic case, and if your store fits it, that's the cheapest route, and we'll tell you so. The work starts where the module doesn't know your conditions: custom order statuses, several warehouses, separate prices for wholesale buyers, non-standard fields on the shipping label. On top of that, we check that the module won't quietly stop working after the next platform update.
It means we don't stop at "the key was accepted and the test payment went through." We check that the order status changed after payment, that the manager sees it in the admin panel, that the shipment was created with the right address, and that the tracking number reached the customer. Most broken integrations are formally connected; they fail at exactly these handoffs.
From a few days for a service with a ready-made module to several weeks for an exchange with an accounting system. The difference lies in the number of fields and rules rather than the connection itself: an exchange with 1C requires deciding, field by field, which system is the source of truth, and those decisions take the time, more than the code does.
Yes, if it has an API and documentation, in which case we write the exchange to match them. If there's no API, the honest answer is that there's nothing to exchange data with, and no amount of custom work will change that. This can be checked within an hour, before any agreements.
It depends on where it got stuck. If the error is in our part, we fix it free of charge under the 30-day warranty. If the gateway itself is down, we can't prevent that, which is exactly why we set up logging: you can see what was sent and how the service responded, so figuring it out takes minutes instead of days of back-and-forth emails.
There's no technical limit, but each new one is another point of failure and another place where something can change without warning. So we recommend connecting what removes manual work right now, not things added just to have them. If an integration doesn't save anyone time, we'll say so.
Yours, always. The payment provider account, the carrier account, and the marketplace account are all set up in the business owner's name. We only get access for the duration of the work and remove it once we're done. Otherwise you couldn't change contractors without losing your payments.
First we check what the service provides: documentation, a test environment, rate limits, and how it reports changes, whether it sends events on its own or only answers requests. Then we decide where the exchange will live: in a platform module, or as a separate service on the server if there are many requests or the service responds slowly. Keys are stored on the server, never in the page code, and registered to your account. We test the whole scenario and, separately, what happens when the service doesn't respond: an order must never get lost silently.
Cloud telephony gives you a number, call recording, and statistics, and the integration makes sure calls don't live separately: a customer record is created or found in the CRM, the manager sees who's calling before picking up, and a missed call becomes a task. On the site, different numbers can be shown depending on the traffic source, so you can see which ads bring in calls. You choose and pay for the telephony provider yourself; we check that its API returns the events you need and connect them to your system.
Describe the task in your own words — we will tell you where to start and whether you need what you came for. If you do not, we will say so.