Stripe Connect or Mollie Connect? Platform payouts for Dutch SaaS
An honest comparison between Stripe Connect and Mollie Connect for building a Dutch SaaS where your customers receive payments themselves - fees, OAuth flow, iDEAL support and what you actually notice in production.
For Salonnare, our customers - beauty salons - wanted to be paid directly by their own clients. Not money flowing through us first; in Europe that's a PSD2 license matter. So we needed a platform payouts model: the salon receives directly, we hold back a platform fee.
Both major players - Stripe Connect and Mollie Connect - offer this. I've integrated both, because our users have different preferences. Here's what determines the choice in practice.
The short answer
- Mollie Connect if you're Dutch market first and iDEAL is your dominant payment method.
- Stripe Connect if you're scaling internationally, card payments are dominant, or you want to fine-tune platform fees at cent level.
- Both integrated if you're SaaS and want to give customers the choice. More work, but lowers onboarding friction significantly.
Fee structure in practice
For an average salon transaction of €45:
| Provider | Method | Fee | Platform share |
|---|---|---|---|
| Stripe Connect | European card | 1.4% + €0.25 = €0.88 | Freely configurable |
| Mollie Connect | iDEAL | €0.29 flat | Freely configurable |
| Mollie Connect | European card | 1.8% + €0.25 = €1.06 | Freely configurable |
For iDEAL-heavy traffic (where Dutch e-commerce sits on average) Mollie is measurably cheaper per transaction. For European cards Stripe is slightly cheaper. But the real win isn't in fees - it's in which method your users actually use. Salonnare's beauty clients pay 70% via iDEAL, so Mollie wins on cost by definition.
OAuth flow: Stripe is more polished
Both platforms use OAuth for Connect onboarding. Your customer clicks a button, gets sent to the provider, completes KYC and returns authorised.
Stripe Connect: Express accounts give your customer a hosted dashboard without you having to build it. Onboarding link is one API call (accountLinks.create), and Stripe handles the entire KYC including document upload and bank account verification. For me this means: I build one button and Stripe does the rest. Account status I fetch via accounts.retrieve(accountId).
Mollie Connect: OAuth flow with client_id, client_secret, redirect_uri. Your customer authorises, you get an access token and refresh token. That refresh token must be stored and used periodically (every 60 minutes) to refresh your access token. You build the dashboard yourself - no hosted page, but more control over UX.
// Mollie Connect token refresh in worker
const response = await fetch('https://api.mollie.com/oauth2/tokens', {
method: 'POST',
body: new URLSearchParams({
grant_type: 'refresh_token',
refresh_token: tenant.mollie_refresh_token,
}),
headers: {
Authorization: 'Basic ' + Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64'),
},
});
Don't forget to schedule that refresh logic. Our worker runs it every 30 minutes for tenants whose token expires within the hour.
Platform fee splitting
Here the implementations differ in small but important ways.
Stripe: application_fee_amount on the PaymentIntent. You specify an amount in cents, Stripe deducts it from the transaction amount and deposits it in your platform account. Clean, predictable.
const intent = await stripe.paymentIntents.create({
amount: 4500,
currency: 'eur',
application_fee_amount: 200, // €2.00 platform fee
}, {
stripeAccount: tenant.stripe_connect_account_id,
});
Mollie: routing array on the Payment, with destination (customer account) and amount. You explicitly define which amounts go where. Slightly more code, but you can do more complex splits (three parties, for example).
const payment = await mollie.payments.create({
amount: { currency: 'EUR', value: '45.00' },
routing: [{ amount: { currency: 'EUR', value: '43.00' }, destination: { type: 'organization', organizationId: tenant.mollie_org_id } }],
}, { testmode: false, profileId: tenant.mollie_profile_id });
SEPA Direct Debit
For recurring payments (subscriptions, memberships) SEPA DD is a must in the Netherlands. Cards-only gives you a 30%+ drop-off on subscription onboarding.
- Stripe: SEPA DD via
payment_method: 'sepa_debit'. Mandate handling is built in, customer gets an email confirmation. Works fine. - Mollie: SEPA DD via
method: 'directdebit'. The first transaction must be a first-payment (regular iDEAL or card) to capture the mandate, after which you can debit. Specific logic in code, but works flawlessly.
For Salonnare's billing side we use Stripe SEPA DD, because our platform billing is central and doesn't need per-tenant onboarding. For the tenant-to-end-customer flow we use Mollie SEPA DD, because tenants more often already have a Mollie account.
Webhooks: a small warning
Both use webhook signing with a secret. Don't forget to capture the raw body before JSON parsing - otherwise signature verification fails.
// In Express, for webhook routes
app.use('/api/payments/webhook', express.raw({ type: 'application/json' }));
I've fallen into this once per project and debugged for two hours. Just set it up correctly from the start.
Why we support both
Salonnare's customers are independent entrepreneurs. Around 60% already had a Mollie account for their existing webshop, 25% had a Stripe account, 15% had neither. Offering both means: during onboarding they click the provider they already know, their KYC is already done, and they're live within ten minutes. In our pricing-tier model that's literally money's worth.
The codebase differs between both flows, but much is abstracted: one payment_provider column on the tenant, one shared interface for createPaymentIntent and createCheckout. The differences sit in the adapter layer.
What I recommend
- Start with Mollie if you're 100% Dutch market.
- Start with Stripe if you're going international from launch or want to scale your product to UK/DE quickly.
- Only build both once you actually see customer onboarding stalling on provider choice. Not preventively - that's over-engineering.
- Test your webhook flow explicitly in production within 24 hours of launch. Webhook bugs don't show up in dev.
Both are production-grade systems. The choice isn't about quality; it's about which provider your customers already use. And in the Netherlands that's still more often Mollie than Stripe.
