KEKS Pay API Integration & OpenData/OpenFinance Protocol Analysis (QR, Parking, ENC, KEKSICA)

1) Transaction ledger API (OpenData schema)

We design an ingestion layer that normalizes raw app signals into an OpenData-style ledger: `occurred_at`, `direction`, `amount`, `currency`, `reference_id`, and `category` tuned for accounting and analytics.

Use case: cashflow monitoring and category-aware reporting that stays consistent across transfers, QR payments, and card top-up contexts.

2) QR commerce order status & settlement feed

For merchant integrations, we map KEKS Pay’s webshop gateway flows into your backend objects (order_id, out_trade_no, amounts, and settlement timestamps), then expose normalized events for downstream reconciliation.

Use case: “order paid” dashboards that automatically link payment confirmations back to your internal catalog and invoice records.

3) GPS parking payment sync

We export parking events as structured rows so your system can trigger reminders, attach receipts, and reconcile mobility spending to the correct vehicle registration list.

Use case: automated corporate fleet reimbursement that matches the right vehicle ID to each paid parking session.

4) ENC highway toll top-up integration

We model highway toll top-ups as first-class ledger entries, so your platform can aggregate route expenses, compute discounts, and reconcile settlement date vs transaction date.

Use case: travel expense automation with clear audit trails for both transaction time and settlement/payment time.

5) Bill payments & donations export

We normalize “service payment” flows into a consistent OpenData contract: `provider_id`, `service_type`, `amount`, `reference_id`, and `status`, enabling analytics across utilities and charity events.

Use case: compliance-friendly reporting that separates bill provider charges from user-initiated donation records.

6) KEKSICA prepaid Visa card events

We export card-linked transactions as normalized payment instrument events so your system can reconcile spend, create card-specific KPIs, and keep “who initiated” logs for auditability.

Use case: prepaid card spend dashboards and operational support tooling when a card is blocked/unblocked inside the app.

Core benefits for integration teams

Instead of treating KEKS Pay as a black box, we build an interface layer that makes payment data predictable for your backend. Each module ships with request/response examples, mapping rules, and a test plan for regression when the app protocol changes.

• OpenData normalization: consistent fields for timestamps, references, fees/commissions, and product types (transfers, QR, parking, ENC)
• Operational safety: idempotency keys, deterministic category mapping, and resilient retry rules for polling/ingestion
• Auditability: integration logs with minimal personal data retention aligned with privacy-by-design expectations
• Source-code delivery: working implementation code plus integration documentation your developers can maintain

API integration instructions (how we connect)

Your team provides the target use case (e.g., “transaction export OpenData”, “QR settlement feed for reconciliation”, or “daily CSV import for accounting”). We then map the authorized app protocol steps into a clean integration boundary for your services.

Typical process: consent/session establishment → authorized data ingestion → normalization & validation → API output for analytics/accounting. We also include test checklists so your team can verify correctness after UI or protocol updates.

Data inventory (OpenData perspective)

The table below lists concrete finance objects that KEKS Pay exposes through its user and merchant experiences. We then design OpenData/OpenFinance exports so your team can reconcile, report, and audit with clear field mappings.

Typical integration scenarios

Each scenario below is written as an end-to-end workflow: business context, which KEKS Pay data/API adapter you expose, and how it maps into OpenData/OpenFinance models for downstream services.

Technical implementation (examples)

The snippets below show how our authorized integration layer is wired. They do not claim KEKS Pay publishes identical endpoints for every use case; instead, they demonstrate the contract your backend can call and the fields you can expect in normalized payloads.

// 1) Merchant QR commerce: create order (example contract you integrate with)
POST https://devwebpayment.kesspay.io/api/mch/v1/gateway
Content-Type: application/json
Authorization: Basic <base64(username:password)>

{
  "service": "webpay.acquire.createorder",
  "sign": "<generated signature>",
  "sign_type": "HMAC-SHA256",
  "seller_id": "<your_seller_id>",
  "out_trade_no": "KEXS-2026-000123",
  "body": "Order payment",
  "total_amount": "39.90",
  "currency": "EUR",
  "detail": [{"name":"SKU-1","quantity":2,"amount":"19.95"}]
}

// Adapter response (normalized):
// { "status":"ok", "order_reference":"...", "out_trade_no":"...", "payment_url_or_qr": "..." }

// 2) Daily settlement CSV ingestion (reconciliation + reversal handling)
// Expected KEKS Pay daily report fields (examples):
DATUM_TRANSAKCIJE, INTERVAL_IZVJESTAJA, DATUM_ISPLATE, IZNOS, PROVIZIJA,
TID, PNB_ISPLATE, OPIS_TRANSAKCIJE, KEKS_ID, REFERENCA

for row in csv_rows:
  tx_date   = parse_date(row.DATUM_TRANSAKCIJE)
  proc_date = parse_date(row.INTERVAL_IZVJESTAJA)
  pay_date  = parse_date(row.DATUM_ISPLATE)
  is_reversal = row.OPIS_TRANSAKCIJE contains "STORNO"
  amount = to_decimal(row.IZNOS)
  fee = to_decimal(row.PROVIZIJA)

  emit settlement_row {
    "transaction_id": row.KEKS_ID,
    "tid": row.TID,
    "reference": row.REFERENCA,
    "gross_amount": amount,
    "commission": fee,
    "settlement_date": pay_date,
    "type": is_reversal ? "REVERSAL" : "SALE"
  }

// 3) Error handling + idempotent retries in your backend
// Adapter call (your system)
POST /api/v1/keks-pay/orders/query
{
  "order_reference": "<order_reference>",
  "idempotency_key": "query:KEXS-2026-000123",
  "max_retries": 5
}

// Example error contract your adapter returns:
{
  "status": "partial",
  "retry_after_seconds": 120,
  "errors": [
    {"code":"RATE_LIMITED", "message":"Too many queries to gateway", "field":"order_reference"}
  ]
}

// Optional webhook endpoint (your system receives normalized events):
POST https://yourapp.com/webhooks/keks-pay/payment-events
{
  "event_id":"evt_...",
  "type":"PAYMENT_CONFIRMED",
  "out_trade_no":"KEXS-2026-000123",
  "settled_at":"2026-03-25T10:10:00Z",
  "amount":"39.90",
  "currency":"EUR"
}

Implementation detail we emphasize: idempotency keys (for example `event_id` / `out_trade_no`), strict field validation for CSV and JSON payloads, and deterministic mapping from raw payment descriptions (including `STORNO` reversals) to OpenData transaction types.

Compliance & privacy (EU-aligned)

KEKS Pay is built in a regulatory environment shaped by PSD2 (Payment Services Directive 2) changes and privacy obligations aligned with GDPR. For integration teams, the practical requirement is simple: build authorized access flows and minimize stored personal data while keeping an audit trail for operational safety.

The app’s security posture includes encrypted communication (HTTPS/SSL) and PIN or biometric authentication for user access. We reflect this in our integration outputs by scoping tokens, logging only necessary identifiers, and recommending retention windows that cover reconciliation needs without indefinite raw-data storage.

Data flow / architecture

Client App or Merchant System → Ingestion/API Adapter (authorized protocol retrieval) → Secure Storage (encrypted raw + structured OpenData tables) → Analytics/Accounting API outputs (normalized events, reconciliation endpoints).

Market positioning & user profile

KEKS Pay is positioned as a Croatian/EMEA mobile payment app for everyday transfers with phone-number convenience, plus consumer-to-merchant QR payments and practical “life services” like parking and ENC highway toll top-ups. It is built for mobile platforms (Android/iOS) while supporting merchant and webshop integration ecosystems (including WooCommerce and Magento 2 modules). That makes it a strong target for OpenData/API integration work spanning B2C usage insights, B2B reconciliation, and compliance-first audit requirements.

Deliverables & what you receive

We deliver a usable integration package, not only analysis notes. The goal is developer-ready output: working implementation code and documentation you can run and validate in your environment.

• API specification (OpenAPI/Swagger-style) for the endpoints you requested
• Protocol analysis & authorization flow report covering the authorized steps and session boundary
• Working integration source code (Python/Node.js/Go skeletons depending on your backend)
• Automated test plan and smoke tests for ledger sync, QR settlement mapping, and CSV ingestion
• Compliance notes (scope design, logging strategy, and data minimization recommendations)
• Developer interface documentation and integration runbooks

About our studio

We are a technical service studio specializing in app interface integration and authorized API integration. Our delivery combines protocol analysis, interface refactoring, OpenData/OpenFinance mapping, and professional documentation so your team can move from protocol knowledge to production.

Team members bring years of hands-on experience across mobile applications and fintech operations, including protocol-analysis workflows, payment data normalization, and testing strategies that keep integration outputs stable over time.

• Compliant-by-design delivery aligned with privacy protection and local handling expectations
• Android/iOS focus with integration-ready code and repeatable test plans
• One-stop support: analysis → implementation → validation → documentation
• Transparent pricing: services start at $300, with an option to deliver results first and pay upon satisfaction

Contact information

Share the target app name (KEKS Pay is already set) and your integration requirements (OpenData transaction export, QR settlement feed, parking GPS sync, ENC top-up reconciliation, or merchant CSV import). For next steps, visit:

Contact / Request a quote

Workflow & proposal steps

1. Requirement alignment: confirm the exact scopes (ledger sync, QR settlement, parking GPS, ENC top-ups, bill payments, settlements import) and success metrics.
2. Protocol analysis & interface design: we produce the mapping plan and endpoint contract (typically 2–5 business days, depending on complexity).
3. Implementation & internal verification: build the ingestion module and normalized API output (typically 3–8 business days).
4. Delivery package: API spec, source code, developer documentation, and tests (typically 1–2 business days).
5. Regression support: we can extend/patch the integration if KEKS Pay updates its protocol or UI flows (optional).

A typical first delivery (vertical slice) often takes 5–15 business days. Regulated flows and additional third-party approvals may extend timeline.

FAQ

What do you need from me?

How do you keep the project compliant?

Do you support recurring sync?