Skip to main content

What is Adyen

Understand what Adyen is and how it works from a developer perspective. Learn the core concepts, APIs, payment flows, and components used to integrate and process payments securely within your application.

Updated over a week ago

Adyen is a global payments platform that provides APIs and infrastructure to accept, process, and manage payments across multiple channels (online, in-person, and mobile).

From a developer perspective, Adyen is not just a payment gateway—it combines:

  • Payment processing

  • Risk management

  • Authentication (e.g., 3D Secure)

  • Payment method orchestration

  • Reporting and lifecycle events (via webhooks)

All of this is exposed through a set of APIs and client-side components.

Core Concept

At its core, integrating Adyen means:

  1. Collecting payment details (securely, usually via Adyen UI components or hosted solutions)

  2. Sending a payment request to Adyen’s API

  3. Handling the response (synchronous or asynchronous)

  4. Reacting to lifecycle events via webhooks (e.g., payment captured, failed, refunded)

Key Building Blocks

When working with Adyen, you will interact with the following core elements:

1. Payments API

Used to create and manage payments.

Example request (simplified):

POST /payments

{
"amount": {
"currency": "EUR",
"value": 1000
},
"reference": "ORDER-12345",
"paymentMethod": {
"type": "scheme",
"number": "4111111111111111",
"expiryMonth": "03",
"expiryYear": "2030",
"cvc": "737"
},
"returnUrl": "https://yourapp.com/redirect"
}

This request:

  • Creates a payment

  • Triggers authentication if required (e.g., 3DS)

  • Returns a result that determines the next step

2. Client-Side Components (Drop-in / Components)

Adyen provides prebuilt UI elements to securely collect payment details.

Instead of handling sensitive card data yourself, you typically use:

  • Drop-in → all-in-one UI

  • Components → individual payment method UIs

This helps:

  • Reduce PCI scope

  • Ensure compliance

  • Speed up integration

3. Sessions vs Advanced Flow

Adyen supports two main integration patterns:

  • Sessions Flow (recommended)
    Backend creates a session → frontend handles most of the flow

  • Advanced Flow
    Full control over /payments and /payments/details calls

Your choice affects:

  • Complexity

  • Control over UX

  • Backend responsibility

4. Webhooks (Notifications)

Not all payment outcomes are immediate.

Adyen sends webhook events to notify your system about:

  • Authorizations

  • Captures

  • Failures

  • Refunds

Example event:

{
"eventCode": "AUTHORISATION",
"success": "true",
"pspReference": "123456789",
"merchantReference": "ORDER-12345"
}

Your system must process these events to:

  • Update order status

  • Trigger business logic

Payment Flow (High-Level)

A typical online payment flow looks like this:

  1. Frontend collects payment details (Drop-in / Components)

  2. Backend sends payment request to Adyen

  3. Adyen returns:

    • Authorised → success

    • Refused → failure

    • RedirectShopper → requires action (e.g., 3DS)

  4. Customer completes any required actions

  5. Adyen sends final status via webhook

Why Adyen (from a developer standpoint)

Adyen is commonly used because it provides:

  • Unified API for multiple payment methods

  • Strong support for global payments

  • Built-in authentication flows (3DS, SCA)

  • Flexible integration options (low-code → full control)

  • Reliable event-driven model via webhooks

How this fits in your integration

Within Valpay integrations, Adyen acts as:

  • The payment processor

  • The source of truth for payment status

  • The system responsible for compliance and authorization

Your application is responsible for:

  • Initiating payments

  • Handling user interaction

  • Processing webhook events

  • Managing business logic (orders, subscriptions, etc.)

Did this answer your question?