> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gr4vy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Adyen - SEPA
> Configure SEPA via Adyen as a payment method in Gr4vy.
export const connector = {
id: "adyen-sepa",
displayName: "SEPA",
provider: "Adyen",
method: "sepa",
mode: "redirect",
category: "bank",
features: "create_transaction deep_linking direct_capture direct_integration_create partial_refunds payment_method_tokenization redirect_requires_popup refunds requires_webhook_setup settlement_reporting settlement_reporting_from_webhook verify_credentials",
supportedCountries: "AT BE BG CY CZ DE DK EE ES FI FR GB GR HR HU IE IT LT LU LV MT NL PL PT RO SE SI SK",
supportedCurrencies: "EUR"
};
export const ConnectorRegions = ({data, kind, name: nameOverride}) => {
const [query, setQuery] = useState("");
const [open, setOpen] = useState(false);
const isCountries = kind === "countries";
const raw = data && (isCountries ? data.supportedCountries : data.supportedCurrencies);
const codes = typeof raw === "string" ? raw.split(/\s+/).filter(Boolean) : Array.isArray(raw) ? raw : [];
const DISPLAY_NAME_OVERRIDES = {
authorizenet: "Authorize.net",
cardpointe: "CardPointe",
cybersource: "Cybersource",
dlocal: "dLocal",
shift4i4go: "Shift4 i4go",
tokenex: "TokenEx"
};
const rawName = data && data.displayName || "";
const name = nameOverride || DISPLAY_NAME_OVERRIDES[rawName.toLowerCase()] || rawName || "This connector";
const verb = isCountries ? "supports transactions from buyers in" : "supports processing payments in";
const noun = isCountries ? "countries" : "currencies";
if (codes.length === 0) return null;
const unrestricted = codes.length >= (isCountries ? 200 : 150);
const disclaimer =
This list is for guidance only. It doesn't guarantee availability or
create any rights, and the provider must also enable each of these {noun}{" "}
for your account.
This list is for guidance only. It doesn't guarantee availability or
create any rights, and the provider may need to enable some features for
your account.
;
};
Adyen is a global payment technology company founded in 2006 in Amsterdam, Netherlands. The company provides a single platform for accepting payments across online, mobile, and in-store channels for major enterprises worldwide including Uber, Spotify, and Microsoft.
SEPA (Single Euro Payments Area) is a payment integration initiative that makes bank transfers within the European Union as easy as domestic transfers. SEPA Direct Debit allows merchants to collect payments directly from buyers' bank accounts across participating European countries, providing a cost-effective alternative to card payments.
**Four Adyen connectors debit a buyer's bank account.** Pick the one that matches who collects the account:
* [ACH Direct Debit](/connections/payments/adyen-ach) (redirect): the buyer enters their account and routing numbers on Adyen's page, and Adyen keeps them.
* [SEPA](/connections/payments/adyen-sepa) (redirect): the buyer enters their IBAN on Adyen's page, and Adyen keeps it.
* [Pay by Bank (redirect)](/connections/payments/adyen-paybybank): Adyen sends the buyer to Plaid to choose their bank. US only.
* [Bank account (ACH, SEPA, BACS)](/connections/payments/adyen-bank) (stored in Gr4vy): you send the bank account details or a Plaid-linked account, and Gr4vy stores the account. Use this connector to charge bank accounts that you [import](/guides/features/token-import/overview) into Gr4vy.
## Setup
Please follow the [common Adyen instructions](./adyen) to get set up with SEPA.
Next, make sure to enable SEPA as a payment method on your configured account.
## Capabilities
## Supported countries
## Supported currencies
## Integration
For SEPA, the default integration for Adyen is through a redirect to a hosted payments page.
### Redirect integration
Start by creating a new transaction with the following required fields.
```csharp C# theme={"system"}
var transaction = await client.Transactions.CreateAsync(
transactionCreate: new TransactionCreate()
{
Amount = 1299,
Currency = "EUR",
Country = "DE",
Intent = "capture",
PaymentMethod =
TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
new RedirectPaymentMethodCreate()
{
Method = "sepa",
Country = "DE",
Currency = "EUR",
RedirectUrl = "https://example.com/callback",
}
),
}
);
```
```go Go theme={"system"}
amount := int64(1299)
currency := "EUR"
country := "DE"
method := components.RedirectPaymentMethodCreateMethodSepa
redirectUrl := "https://example.com/callback"
redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
Method: method,
Country: country,
Currency: currency,
RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)
transactionCreate := components.TransactionCreate{
Amount: amount,
Currency: currency,
Country: &country,
Intent: gr4vy.Pointer(components.TransactionIntentCapture),
PaymentMethod: &paymentMethod,
}
transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
```
```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
.transactionCreate(TransactionCreate.builder()
.amount(1299L)
.currency("EUR")
.country("DE")
.intent(TransactionIntent.CAPTURE)
.paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
.method(RedirectPaymentMethodCreateMethod.SEPA)
.country("DE")
.currency("EUR")
.redirectUrl("https://example.com/callback")
.build()))
.build())
.call();
Transaction transaction = transactionResponse.transaction().orElse(null);
```
```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
amount: 1299,
currency: 'EUR',
country: 'DE',
intent: 'capture',
paymentMethod: new RedirectPaymentMethodCreate(
method: 'sepa',
country: 'DE',
currency: 'EUR',
redirectUrl: 'https://example.com/callback'
)
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;
```
```python Python theme={"system"}
transaction: models.Transaction = client.transactions.create(
amount=1299,
currency="EUR",
country="DE",
intent="capture",
payment_method={
"method": "sepa",
"country": "DE",
"currency": "EUR",
"redirect_url": "https://example.com/callback",
}
)
```
```ts TypeScript theme={"system"}
const transaction = await gr4vy.transactions.create({
amount: 1299,
currency: "EUR",
country: "DE",
intent: "capture",
paymentMethod: {
method: "sepa",
country: "DE",
currency: "EUR",
redirectUrl: "https://example.com/callback"
}
})
```
After the transaction is created, the API response includes `payment_method.approval_url` and the `buyer_approval_pending` status.
```json theme={"system"}
{
"type": "transaction",
"id": "ea1efdd0-20f9-44d9-9b0b-0a3d71e9b625",
"payment_method": {
"type": "payment-method",
"approval_url": "https://cdn.sandbox.spider.gr4vy.app/connectors/adyen/apm.html?token=..."
},
"method": "sepa"
}
```
Redirect the buyer to the `approval_url` so they can complete authentication and approve the payment. After approval the buyer is redirected to the `redirect_url` you provided when creating the transaction. Do not rely solely on the redirect - either poll the transaction or (recommended) rely on webhooks to detect the final status (for example `capture_succeeded` or failure states).
### Direct integration
Adyen provides [web](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Web\&integration=Components\&version=6.23.0), [Android](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components\&version=5.15.0) and [iOS](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=iOS\&integration=Components\&version=5.21.1) SDKs for a direct integration. For these flows you should indicate the platform by setting an appropriate `integration_client` when creating the transaction, and then build a client-side integration that uses the [`POST /transactions/:transaction_id/session`](/reference/transactions/get-transaction-session) API to initialize the Adyen SDK.
To start, create a new transaction with the appropriate `integration_client`.
```csharp C# theme={"system"}
var transaction = await client.Transactions.CreateAsync(
transactionCreate: new TransactionCreate()
{
Amount = 1299,
Currency = "EUR",
Country = "DE",
Intent = "capture",
IntegrationClient = "ios",
PaymentMethod =
TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
new RedirectPaymentMethodCreate()
{
Method = "sepa",
Country = "DE",
Currency = "EUR",
RedirectUrl = "https://example.com/callback",
}
),
}
);
```
```go Go theme={"system"}
amount := int64(1299)
currency := "EUR"
country := "DE"
integrationClient := "ios"
method := components.RedirectPaymentMethodCreateMethodSepa
redirectUrl := "https://example.com/callback"
redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
Method: method,
Country: country,
Currency: currency,
RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)
transactionCreate := components.TransactionCreate{
Amount: amount,
Currency: currency,
Country: &country,
Intent: gr4vy.Pointer(components.TransactionIntentCapture),
IntegrationClient: &integrationClient,
PaymentMethod: &paymentMethod,
}
transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
```
```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
.transactionCreate(TransactionCreate.builder()
.amount(1299L)
.currency("EUR")
.country("DE")
.intent(TransactionIntent.CAPTURE)
.integrationClient("ios")
.paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
.method(RedirectPaymentMethodCreateMethod.SEPA)
.country("DE")
.currency("EUR")
.redirectUrl("https://example.com/callback")
.build()))
.build())
.call();
Transaction transaction = transactionResponse.transaction().orElse(null);
```
```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
amount: 1299,
currency: 'EUR',
country: 'DE',
intent: 'capture',
integrationClient: 'ios',
paymentMethod: new RedirectPaymentMethodCreate(
method: 'sepa',
country: 'DE',
currency: 'EUR',
redirectUrl: 'myapp://callback'
)
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;
```
```python Python theme={"system"}
transaction: models.Transaction = client.transactions.create(
amount=1299,
currency="EUR",
country="DE",
intent="capture",
integration_client="ios",
payment_method={
"method": "sepa",
"country": "DE",
"currency": "EUR",
"redirect_url": "https://example.com/callback",
}
)
```
```ts TypeScript theme={"system"}
const transaction = await gr4vy.transactions.create({
amount: 1299,
currency: "EUR",
country: "DE",
intent: "capture",
integrationClient: "ios",
paymentMethod: {
method: "sepa",
country: "DE",
currency: "EUR",
redirectUrl: "https://example.com/callback"
}
})
```
For mobile, set `integration_client` to `ios` or `android` and use your app deep link for `redirect_url` (for example, `yourapp://`).
After the transaction is created, the API response includes a `session_token` which can be used to get the [session data](/reference/transactions/get-transaction-session) for that transaction.
```sh theme={"system"}
POST /transactions/:transaction_id/session?token=:session_token
```
```json Web theme={"system"}
{
"session_data": {
"sessionId": "CS04C0B8AC9849A7D8E25B20D",
"sessionData": "Ab02b4c0!BQABAgBLgbLpvkt1r3",
"environment": "live",
"clientKey": "client-key",
"returnUrl": "https://example.com/callback",
"paymentMethod": "sepa",
"storePaymentMethod": true
},
"default_completion_url": "https://api.sandbox.spider.gr4vy.app/transactions/approve/some-token",
"integration_client": "web"
}
```
```json iOS theme={"system"}
{
"session_data": {
"sessionId": "CS04C0B8AC9849A7D8E25B20D",
"sessionData": "Ab02b4c0!BQABAgBLgbLpvkt1r3",
"environment": "live",
"clientKey": "client-key",
"returnUrl": "yourapp://",
"paymentMethod": "sepa",
"storePaymentMethod": true
},
"default_completion_url": "https://api.sandbox.spider.gr4vy.app/transactions/approve/some-token",
"integration_client": "ios"
}
```
```json Android theme={"system"}
{
"session_data": {
"sessionId": "CS04C0B8AC9849A7D8E25B20D",
"sessionData": "Ab02b4c0!BQABAgBLgbLpvkt1r3",
"environment": "live",
"clientKey": "client-key",
"returnUrl": "yourapp://",
"paymentMethod": "sepa",
"storePaymentMethod": true
},
"default_completion_url": "https://api.sandbox.spider.gr4vy.app/transactions/approve/some-token",
"integration_client": "android"
}
```
This session data provides the `sessionId` and `sessionData` required to load the Adyen SDK.
```js Web theme={"system"}
const adyenEnvironment = sessionData.environment;
const clientKey = sessionData.clientKey;
const sessionId = sessionData.sessionId;
const adyenSessionData = sessionData.sessionData;
const returnUrl = sessionData.returnUrl;
const paymentMethod = sessionData.paymentMethod;
const storePaymentMethod = sessionData.storePaymentMethod;
const configuration = {
environment: adyenEnvironment,
clientKey,
analytics: {
enabled: false,
},
session: {
id: sessionId,
sessionData: adyenSessionData,
},
}
AdyenCheckout(configuration).then(function (checkout) {
let component = checkout
.create(paymentMethod)
.mount('#component');
});
```
```swift iOS theme={"system"}
var adyenEnvironment = sessionData.environment;
var clientKey = sessionData.clientKey;
var sessionId = sessionData.sessionId;
var adyenSessionData = sessionData.sessionData;
var returnUrl = sessionData.returnUrl;
var paymentMethod = sessionData.paymentMethod;
var storePaymentMethod = sessionData.storePaymentMethod;
override func viewDidLoad() {
super.viewDidLoad()
let configuration = AdyenSession.Configuration(sessionIdentifier: sessionId,
initialSessionData: adyenSessionData)
AdyenSession.initialize(with: configuration, delegate: self, presentationDelegate: self) { [weak self] result in
switch result {
case let .success(session):
//Store the session object.
self?.session = session
case let .failure(error):
//Handle the error.
}
}
}
```
```kotlin Android theme={"system"}
val adyenEnvironment = sessionData.environment;
val clientKey = sessionData.clientKey;
val sessionId = sessionData.sessionId;
val adyenSessionData = sessionData.sessionData;
val returnUrl = sessionData.returnUrl;
val paymentMethod = sessionData.paymentMethod;
val storePaymentMethod = sessionData.storePaymentMethod;
// Create the session object
val checkoutSession = CheckoutSession(
session = Session(id = sessionId, sessionData = adyenSessionData),
environment = Environment.TEST,
clientKey = clientKey
)
when (result) {
is CheckoutSessionResult.Success -> handleCheckoutSession(result.checkoutSession)
is CheckoutSessionResult.Error -> handleError(result.exception)
}
```
#### Complete the transaction
Recommended
On mobile integrations, after the buyer completes the payment flow, the Adyen SDK provides the developer with an `onFinished` call, which includes a `statusCode`.
The system automatically syncs the status through webhooks, but to complete the transaction it is also recommended sending a `GET` request to the `default_completion_url` provided in the session response with the `sessionId` and the `sessionResult` as query parameters to finalize the transaction. This also moves the transaction to a completed status without waiting for the webhook to be sent.
The call returns a `204 No Content` response. After receiving this response, you can also optionally fetch the transaction to confirm final status.
```swift iOS theme={"system"}
func didComplete(with result: AdyenSessionResult,
component: Component,
session: AdyenSession)
{
var urlComponents = URLComponents(string: defaultCompletionUrl)!
urlComponents.queryItems = [
URLQueryItem(name: "sessionId", value: session.session.id),
URLQueryItem(name: "sessionResult", value: result.sessionResult)
]
var request = URLRequest(url: urlComponents.url!)
request.httpMethod = "GET"
let task = URLSession.shared.dataTask(with: request) { data, response, error in
// Handle 204 response, you can now poll the transaction
}
task.resume()
}
```
```kotlin Android theme={"system"}
override fun onFinished(result: SessionPaymentResult) {
val sessionResult = result.sessionResult
val uri = Uri.parse(defaultCompletionUrl)
.buildUpon()
.appendQueryParameter("sessionId", result.sessionId)
.appendQueryParameter("sessionResult", sessionResult)
.build()
val url = URL(uri.toString())
val urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = "GET"
val responseCode = urlConnection.responseCode
if (responseCode == HttpURLConnection.HTTP_NO_CONTENT) {
// Handle 204 response, you can now poll the transaction
}
}
```
Please refer to the Adyen documentation for the [web](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Web\&integration=Components\&version=6.23.0), [Android](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=Android\&integration=Components\&version=5.15.0) and [iOS](https://docs.adyen.com/online-payments/build-your-integration/sessions-flow?platform=iOS\&integration=Components\&version=5.21.1) for further guidance.
### Recurring payments
SEPA via Adyen supports recurring payments. To process a recurring payment, please be aware of the following limitations when storing a SEPA payment method for future use.
* To store a SEPA payment for future use, set `store: true` on the transaction request.
* When stored, a SEPA payment method is initially in a `processing` state until a webhook is received from Adyen. You need to set up the Adyen `RECURRING_CONTRACT` webhooks for this update to be received.
* A stored SEPA payment method in a `processing` state can not be used in Embed until it is ready and marked as `succeeded`
Once a SEPA payment method is successfully stored, you can use it to create a subsequent payment.
```csharp C# theme={"system"}
var transaction = await client.Transactions.CreateAsync(
transactionCreate: new TransactionCreate()
{
Amount = 1800,
Currency = "EUR",
Country = "DE",
Intent = "capture",
PaymentMethod = TransactionCreatePaymentMethod.CreateTokenPaymentMethodCreate(
new TokenPaymentMethodCreate()
{
Id = "f758d736-9a81-4bd0-85a9-2d3ee361b863"
}
),
IsSubsequentPayment = true,
MerchantInitiated = true,
PaymentSource = "recurring"
}
);
```
```go Go theme={"system"}
amount := int64(1800)
currency := "EUR"
country := "DE"
paymentSource := components.TransactionPaymentSourceRecurring
tokenPaymentMethodCreate := components.TokenPaymentMethodCreate{
ID: "f758d736-9a81-4bd0-85a9-2d3ee361b863",
}
paymentMethod := components.CreateTransactionCreatePaymentMethodTokenPaymentMethodCreate(tokenPaymentMethodCreate)
transactionCreate := components.TransactionCreate{
Amount: amount,
Currency: currency,
Country: &country,
Intent: gr4vy.Pointer(components.TransactionIntentCapture),
PaymentMethod: &paymentMethod,
IsSubsequentPayment: gr4vy.Bool(true),
MerchantInitiated: gr4vy.Bool(true),
PaymentSource: &paymentSource,
}
transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
```
```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
.transactionCreate(TransactionCreate.builder()
.amount(1800L)
.currency("EUR")
.country("DE")
.intent(TransactionIntent.CAPTURE)
.paymentMethod(TransactionCreatePaymentMethod.of(TokenPaymentMethodCreate.builder()
.id("f758d736-9a81-4bd0-85a9-2d3ee361b863")
.build()))
.isSubsequentPayment(true)
.merchantInitiated(true)
.paymentSource(TransactionPaymentSource.RECURRING)
.build())
.call();
Transaction transaction = transactionResponse.transaction().orElse(null);
```
```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
amount: 1800,
currency: 'EUR',
country: 'DE',
intent: 'capture',
paymentMethod: new TokenPaymentMethodCreate(
id: 'f758d736-9a81-4bd0-85a9-2d3ee361b863'
),
isSubsequentPayment: true,
merchantInitiated: true,
paymentSource: 'recurring'
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;
```
```python Python theme={"system"}
transaction: models.Transaction = client.transactions.create(
amount=1800,
currency="EUR",
country="DE",
intent="capture",
payment_method=models.TokenPaymentMethodCreate(
id="f758d736-9a81-4bd0-85a9-2d3ee361b863"
),
is_subsequent_payment=True,
merchant_initiated=True,
payment_source="recurring"
)
```
```ts TypeScript theme={"system"}
const transaction = await gr4vy.transactions.create({
amount: 1800,
currency: "EUR",
country: "DE",
intent: "capture",
paymentMethod: {
method: "id",
id: "f758d736-9a81-4bd0-85a9-2d3ee361b863"
},
isSubsequentPayment: true,
merchantInitiated: true,
paymentSource: "recurring"
})
```
When processing a recurring payment please note the following.
* SEPA supports the `payment_source` of `recurring` and `instalment`, which maps to `Subscription` on the Adyen API. In all other scenarios it sets the recurring processing mode as `UnscheduledCardOnFile`.
* Until the first transaction is settled, a stored SEPA payment uses a different mandate for the subsequent request. In a production environment, this might lead to a subsequent payment failing if the original mandate has not been fully settled yet.
### Auto-rescue
Adyen's [auto-rescue](https://docs.adyen.com/online-payments/auto-rescue/sepa/) feature is supported
by this connector. This feature automatically retries customer-not-present direct debit
transactions when they receive a chargeback.
To enable this feature, pass in the following connection options for Adyen when making a subsequent payment request.
```csharp C# theme={"system"}
var transaction = await client.Transactions.CreateAsync(
transactionCreate: new TransactionCreate()
{
Amount = 1299,
Country = "DE",
Currency = "EUR",
Intent = "capture",
PaymentMethod = TransactionCreatePaymentMethod.CreateTokenPaymentMethodCreate(
new TokenPaymentMethodCreate()
{
Id = "7f6fb9ca-eb1c-42c6-9b65-8f1c699b84bd"
}
),
ConnectionOptions = new Dictionary
{
["adyen-sepa"] = new Dictionary
{
["autoRescue"] = true,
["maxDaysToRescue"] = 5
}
},
PaymentSource = "card_on_file",
IsSubsequentPayment = true,
MerchantInitiated = true
}
);
```
```go Go theme={"system"}
amount := int64(1299)
country := "DE"
currency := "EUR"
paymentSource := components.TransactionPaymentSourceCardOnFile
tokenPaymentMethodCreate := components.TokenPaymentMethodCreate{
ID: "7f6fb9ca-eb1c-42c6-9b65-8f1c699b84bd",
}
paymentMethod := components.CreateTransactionCreatePaymentMethodTokenPaymentMethodCreate(tokenPaymentMethodCreate)
transactionCreate := components.TransactionCreate{
Amount: amount,
Country: &country,
Currency: currency,
Intent: gr4vy.Pointer(components.TransactionIntentCapture),
PaymentMethod: &paymentMethod,
ConnectionOptions: map[string]interface{}{
"adyen-sepa": map[string]interface{}{
"autoRescue": true,
"maxDaysToRescue": 5,
},
},
PaymentSource: &paymentSource,
IsSubsequentPayment: gr4vy.Bool(true),
MerchantInitiated: gr4vy.Bool(true),
}
transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)
```
```java Java theme={"system"}
CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
.transactionCreate(TransactionCreate.builder()
.amount(1299L)
.country("DE")
.currency("EUR")
.intent(TransactionIntent.CAPTURE)
.paymentMethod(TransactionCreatePaymentMethod.of(TokenPaymentMethodCreate.builder()
.id("7f6fb9ca-eb1c-42c6-9b65-8f1c699b84bd")
.build()))
.connectionOptions(Map.of(
"adyen-sepa", Map.of(
"autoRescue", true,
"maxDaysToRescue", 5
)
))
.paymentSource(TransactionPaymentSource.CARD_ON_FILE)
.isSubsequentPayment(true)
.merchantInitiated(true)
.build())
.call();
Transaction transaction = transactionResponse.transaction().orElse(null);
```
```php PHP theme={"system"}
$transactionCreate = new TransactionCreate(
amount: 1299,
country: 'DE',
currency: 'EUR',
intent: 'capture',
paymentMethod: new TokenPaymentMethodCreate(
id: '7f6fb9ca-eb1c-42c6-9b65-8f1c699b84bd'
),
connectionOptions: [
'adyen-sepa' => [
'autoRescue' => true,
'maxDaysToRescue' => 5
]
],
paymentSource: 'card_on_file',
isSubsequentPayment: true,
merchantInitiated: true
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;
```
```python Python theme={"system"}
transaction: models.Transaction = client.transactions.create(
amount=1299,
country="DE",
currency="EUR",
intent="capture",
payment_method=models.TokenPaymentMethodCreate(
id="7f6fb9ca-eb1c-42c6-9b65-8f1c699b84bd"
),
connection_options={
"adyen-sepa": {
"autoRescue": True,
"maxDaysToRescue": 5
}
},
payment_source="card_on_file",
is_subsequent_payment=True,
merchant_initiated=True
)
```
```ts TypeScript theme={"system"}
const transaction = await gr4vy.transactions.create({
amount: 1299,
country: "DE",
currency: "EUR",
intent: "capture",
paymentMethod: {
method: "id",
id: "7f6fb9ca-eb1c-42c6-9b65-8f1c699b84bd"
},
connectionOptions: {
"adyen-sepa": {
autoRescue: true,
maxDaysToRescue: 5
}
},
paymentSource: "card_on_file",
isSubsequentPayment: true,
merchantInitiated: true
})
```
Please note that this feature only works for customer-not-present transactions where `is_subsequent_payment` is set to `true`.
The following fields need to be set.
* `autoRescue` - A boolean value that enables the feature. This defaults to `false`.
* `maxDaysToRescue` - The rescue window, in days. You can specify between 1 and 42 days. Adyen recommends using a rescue window of one calendar month (30 days).
* `autoRescueScenario` - This is one of the [test scenarios](https://docs.adyen.com/online-payments/auto-rescue/sepa/#test-auto-rescue) as defined by Adyen. This only works in sandbox.
* `ownerName` - Set this to the type of chargeback that you want to simulate. Use a concatenation of chargeback and the reason code. For example, `chargeback:MS03` or `chargeback:AM04`. This only works in sandbox.
Auto-rescued SEPA transactions are always `capture_succeeded` in the system as the payment
is always processed successfully initially. Instead, the auto-rescue fights the chargeback by re-attempting the payment.
The system does not report on these attempts, but may report the chargeback in settlement reports.
## Testing
In a test environment, you can simulate a SEPA payment.
Adyen has [extensive instructions](https://docs.adyen.com/payment-methods/sepa-direct-debit/web-component/#test-and-go-live) on how
to help with this.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.
setLogoStage(logoStage + 1)} style={{
width: "3.5rem",
height: "3.5rem",
borderRadius: "0.5rem",
margin: 0,
flexShrink: 0
}} /> : }
setChipLogoFailed(true)} style={{
width: "1rem",
height: "1rem",
borderRadius: "0.2rem",
margin: 0
}} />}
{chipLabel}
: null}
{category ? {category} : null}
{flowLabel ? {flowLabel} : null}