Migrating from Wordline

A practical guide for travel businesses migrating from Wordline (formerly Ingenico ePayments / Ogone) to Felloh. This covers concept mapping, code migration patterns, and a step-by-step migration plan so you can move with confidence.

Wordline is a traditional European payment processor with roots in Ingenico and Ogone. Many travel businesses adopted it years ago and now run on legacy integration patterns — redirect-based hosted checkout pages, PSPID-based authentication, and server-to-server APIs that have evolved through multiple rebrandings. Felloh replaces the gateway and adds the travel-specific layer, letting you modernise your payment stack in one move.

Concept mapping

Understand how Wordline concepts translate to Felloh before writing any code.

Direct equivalents

Different concepts

Felloh concepts with no Wordline equivalent

These are features you gain by moving to Felloh.

No Felloh equivalent

The booking model

The biggest conceptual shift is that every payment in Felloh is tied to a Booking. In Wordline, you submit a payment with an order.references.merchantReference — the gateway has no concept of what the payment is for. In Felloh, you create a booking first, then collect payments against it.

Wordline flow:
  merchantReference → CreatePayment / HostedCheckout → Capture
  (you maintain the link to your booking system)

Felloh flow:
  Customer → Booking → Payment Link / Ecommerce / Scheduled Payment → Transaction
  (booking is a first-class object — payments are linked automatically)

This means you can remove any custom code that links Wordline payment IDs or merchant references to your booking system. Felloh handles this relationship natively.

Choosing a payment method

In Wordline, you call CreatePayment, CreateHostedCheckout, or use the older Ogone form POST. In Felloh, you choose based on the scenario:

Code migration

Authentication

Wordline uses API key ID and secret (or the older PSPID with SHA passphrase for Ogone). Felloh uses a public/private key pair to generate a bearer token.

import { createClient } from 'connect-sdk-nodejs';

// Wordline Connect SDK
const client = createClient({
  host: 'eu.api-ingenico.com',
  scheme: 'https',
  port: 443,
  enableLogging: false,
  apiKeyId: 'your-api-key-id',
  secretApiKey: 'your-secret-api-key',
});

const merchantId = 'your-merchant-id';

Creating a customer

Wordline doesn't have a dedicated customer creation API — customer details are passed with each payment or stored as part of a token/alias. Felloh has a dedicated customer resource.

// Wordline — customer details are embedded in the payment request
const paymentRequest = {
  order: {
    amountOfMoney: { amount: 50000, currencyCode: 'GBP' },
    customer: {
      contactDetails: { emailAddress: 'sarah@example.com' },
      personalInformation: {
        name: { firstName: 'Sarah', surname: 'Jones' },
      },
      billingAddress: {
        street: '10 Downing Street',
        city: 'London',
        zip: 'SW1A 2AA',
        countryCode: 'GB',
      },
    },
    references: { merchantReference: 'TRIP-2026-001' },
  },
  // ... payment method details ...
};

Creating a booking (new concept)

This has no Wordline equivalent — it's the step that replaces your custom booking-to-payment mapping.

const response = await axios({
  method: 'post',
  url: 'https://api.felloh.com/agent/bookings',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${token}`,
  },
  data: {
    organisation: 'your-organisation-id',
    booking_reference: 'TRIP-2026-001',
    gross: 150000,            // £1,500.00 in pence
    currency: 'GBX',
    customer_email: 'sarah@example.com',
    customer_name: 'Sarah Jones',
    departure_date: '2026-08-15',
    return_date: '2026-08-22',
  },
});

Collecting a payment

// Create a hosted checkout session
const hostedCheckout = await client.hostedcheckouts.create(merchantId, {
  order: {
    amountOfMoney: { amount: 50000, currencyCode: 'GBP' },
    customer: {
      contactDetails: { emailAddress: 'sarah@example.com' },
    },
    references: { merchantReference: 'TRIP-2026-001-DEP' },
  },
  hostedCheckoutSpecificInput: {
    returnUrl: 'https://example.com/checkout/result',
    variant: 'your-template-id',
  },
});

// Redirect customer to: hostedCheckout.partialRedirectUrl

Processing a refund

// Wordline — refund is a maintenance operation on the payment ID
const refund = await client.payments.refund(merchantId, paymentId, {
  amountOfMoney: { amount: 20000, currencyCode: 'GBP' },
});
// Refund status comes via webhook

Scheduling a future payment

Wordline supports tokenised payments, but you schedule the timing yourself. Felloh handles scheduling natively.

// Save the card on first payment by enabling tokenisation
const payment = await client.payments.create(merchantId, {
  order: {
    amountOfMoney: { amount: 50000, currencyCode: 'GBP' },
    references: { merchantReference: 'TRIP-2026-001-DEP' },
  },
  cardPaymentMethodSpecificInput: {
    tokenize: true,
    // ... card details or hosted tokenization reference ...
  },
});

// Later, charge the saved token (you schedule via your own cron job)
const recurringPayment = await client.payments.create(merchantId, {
  order: {
    amountOfMoney: { amount: 100000, currencyCode: 'GBP' },
    references: { merchantReference: 'TRIP-2026-001-BAL' },
  },
  cardPaymentMethodSpecificInput: {
    token: 'token-from-initial-payment',
    isRecurring: true,
  },
});

Currency mapping

Wordline uses standard ISO 4217 currency codes with amounts in minor units. Felloh uses minor-unit currency codes. The numeric values are the same — only the code changes.

const WORDLINE_TO_FELLOH_CURRENCY = {
  GBP: 'GBX',
  USD: 'USX',
  EUR: 'EUX',
};

function convertCurrency(wordlineCurrency) {
  const fellohCurrency = WORDLINE_TO_FELLOH_CURRENCY[wordlineCurrency.toUpperCase()];
  if (!fellohCurrency) {
    throw new Error(`Unsupported currency: ${wordlineCurrency}`);
  }
  return fellohCurrency;
}

// Amount values stay the same — both use minor units
// Wordline: { amount: 150000, currencyCode: 'GBP' }
// Felloh:   { amount: 150000, currency: 'GBX' }

Webhook event mapping

Wordline uses webhook notifications (or the older Ogone server-to-server feedback). Felloh uses standard webhooks with HMAC-SHA256 signatures.

Migrating a webhook handler

import crypto from 'crypto';

app.post('/webhooks/wordline', express.json(), (req, res) => {
  // Verify Wordline signature
  const signature = req.headers['x-gcs-signature'];
  const keyId = req.headers['x-gcs-keyid'];

  // Wordline uses HMAC-SHA256 with your webhook secret
  const body = JSON.stringify(req.body);
  const expected = crypto
    .createHmac('sha256', webhookSecret)
    .update(body)
    .digest('base64');

  if (signature !== expected) {
    return res.status(401).send('Invalid signature');
  }

  const event = req.body;

  if (event.payment) {
    switch (event.payment.status) {
      case 'CAPTURED':
        handlePaymentSuccess(event.payment);
        break;
      case 'REJECTED':
        handlePaymentFailure(event.payment);
        break;
    }
  } else if (event.refund) {
    if (event.refund.status === 'REFUNDED') {
      handleRefund(event.refund);
    }
  }

  res.status(200).send('OK');
});

What you can remove

Migrating from Wordline to Felloh lets you remove significant custom code — especially if you're on an older Ogone-era integration.

Migrating from the older Ogone integration

If you're still on the Ogone-era e-Commerce form POST integration, the migration to Felloh is even more impactful. Here's what changes:

<!-- Ogone hidden form POST pattern -->
<form method="post" action="https://secure.ogone.com/ncol/prod/orderstandard.asp">
  <input type="hidden" name="PSPID" value="your-pspid">
  <input type="hidden" name="ORDERID" value="TRIP-2026-001">
  <input type="hidden" name="AMOUNT" value="50000">
  <input type="hidden" name="CURRENCY" value="GBP">
  <input type="hidden" name="LANGUAGE" value="en_US">
  <input type="hidden" name="EMAIL" value="sarah@example.com">
  <input type="hidden" name="SHASIGN" value="calculated-sha-signature">
  <input type="submit" value="Pay Now">
</form>

Migration plan

A step-by-step approach to moving from Wordline to Felloh.

Phase 1 — Set up and validate

1. Create a Felloh account and generate sandbox API keys from the Sandbox Registration Form
2. Set up authentication — implement token generation and caching
3. Create a test booking and payment link to verify your integration works
4. Connect the MCP server (optional) — useful for exploring the API interactively during migration

Phase 2 — Audit and plan

1. Identify your Wordline integration type — are you on the newer Connect API, the older Ogone form POST, or a mix?
2. List all payment flows — hosted checkout, direct API, tokenised recurring, batch files
3. Create customers in Felloh — pull customer data from your booking system
4. Create bookings for any active reservations
5. Map your existing order IDs / merchant references to Felloh bookings using the booking_reference field

Phase 3 — Migrate payment flows

1. Replace hosted checkout / Ogone form POST with Felloh payment links
2. Replace direct API / hosted tokenization with Felloh ecommerce sessions and the Felloh SDK
3. Replace token-based recurring payments (cron jobs or batch files) with Felloh scheduled payments
4. Replace refund maintenance operations with Felloh's two-stage refund process
5. Replace Wordline webhook handlers with Felloh webhook handlers
6. Remove capture logic — Felloh handles capture automatically
7. Remove SHA signature calculation code — Felloh uses standard HMAC-SHA256

Phase 4 — Test in sandbox

1. Run through every payment flow in the Felloh sandbox
2. Test edge cases: declined payments, partial refunds, expired tokens
3. Verify webhook delivery and handling
4. Confirm customer-facing payment pages work correctly

Phase 5 — Go live

1. Switch to production API keys
2. Run Wordline and Felloh in parallel for a transition period — new bookings go through Felloh, existing Wordline payments settle naturally
3. Monitor the Felloh Dashboard for transaction status
4. Decommission Wordline integration and remove legacy code
5. Cancel Wordline Fraud Professional add-on (now covered by Fraud Shield)

Common migration questions

Can I run Wordline and Felloh in parallel? Yes. Route new bookings to Felloh and let existing Wordline transactions settle naturally. There's no conflict between the two.

Do I need to re-collect card details? Yes, for new payments. Wordline tokens/aliases are not transferable to Felloh. Customers will enter their card details on their first Felloh payment, and the card is automatically tokenised for future use.

What about PCI compliance? Felloh handles PCI compliance the same way — card details are collected via Felloh's hosted payment pages or SDK, never touching your servers. If you were using Wordline's Hosted Tokenization Page, the Felloh SDK provides equivalent security.

I'm still on the old Ogone integration. Is migration harder? Actually, it's often easier — the Ogone form POST pattern is simple but inflexible. You replace the form and SHA signature logic with a single Felloh API call. See the Ogone migration section above.

I use Wordline batch files for recurring payments. How does that translate? Replace batch files with individual Felloh scheduled payments. Each scheduled payment has a specific execution date and amount — Felloh handles the execution automatically. No batch files, no cron jobs.

What about 3DS (Strong Customer Authentication)? Felloh handles 3DS automatically on payment links and ecommerce sessions. You can configure 3DS rules in Fraud Shield — for example, setting velocity thresholds for when 3DS challenges are triggered.

Can I use the Felloh MCP server during migration? Absolutely. Connect the MCP server to your AI editor and use it to explore the API, create test bookings, and debug your integration interactively.