Endpoint catalog

curl --request POST \
  --url 'https://api.sandbox.deuna.io/merchants/orders' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Idempotency-Key: IDEMPOTENCY_KEY' \
  --header 'X-Prediction-Id: PREDICTION_ID_VALUE' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/merchants/orders", {
  method: "POST",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Idempotency-Key": "IDEMPOTENCY_KEY",
    "X-Prediction-Id": "PREDICTION_ID_VALUE",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/merchants/orders",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Idempotency-Key": "IDEMPOTENCY_KEY",
        "X-Prediction-Id": "PREDICTION_ID_VALUE",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/orders",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Idempotency-Key: IDEMPOTENCY_KEY",
    "X-Prediction-Id: PREDICTION_ID_VALUE",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/orders"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Idempotency-Key", "IDEMPOTENCY_KEY")
      .header("X-Prediction-Id", "PREDICTION_ID_VALUE")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/merchants/orders", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Idempotency-Key", "IDEMPOTENCY_KEY")
  request.Header.Set("X-Prediction-Id", "PREDICTION_ID_VALUE")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/merchants/orders/{order_token}' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'x-merchant-id: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/merchants/orders/{order_token}", {
  method: "GET",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "x-merchant-id": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/merchants/orders/{order_token}",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "x-merchant-id": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/orders/{order_token}",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "x-merchant-id: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/orders/{order_token}"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("x-merchant-id", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/merchants/orders/{order_token}", nil)
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("x-merchant-id", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/merchants/orders/{order_token}/payments-methods' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Store-Code: STORE_CODE'

const response = await fetch("https://api.sandbox.deuna.io/merchants/orders/{order_token}/payments-methods", {
  method: "GET",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Store-Code": "STORE_CODE"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/merchants/orders/{order_token}/payments-methods",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Store-Code": "STORE_CODE"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/orders/{order_token}/payments-methods",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Store-Code: STORE_CODE"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/orders/{order_token}/payments-methods"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Store-Code", "STORE_CODE")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/merchants/orders/{order_token}/payments-methods", nil)
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Store-Code", "STORE_CODE")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/v2/merchants/orders/purchase' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'Cookie: COOKIE_VALUE' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-ID: MERCHANT_ID' \
  --header 'X-Prediction-Id: PREDICTION_ID_VALUE' \
  --header 'X-Session-Id: SESSION_ID' \
  --header 'X-Store-Code: STORE_CODE' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/v2/merchants/orders/purchase", {
  method: "POST",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "Cookie": "COOKIE_VALUE",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-ID": "MERCHANT_ID",
    "X-Prediction-Id": "PREDICTION_ID_VALUE",
    "X-Session-Id": "SESSION_ID",
    "X-Store-Code": "STORE_CODE",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/v2/merchants/orders/purchase",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "Cookie": "COOKIE_VALUE",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-ID": "MERCHANT_ID",
        "X-Prediction-Id": "PREDICTION_ID_VALUE",
        "X-Session-Id": "SESSION_ID",
        "X-Store-Code": "STORE_CODE",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/v2/merchants/orders/purchase",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "Cookie: COOKIE_VALUE",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-ID: MERCHANT_ID",
    "X-Prediction-Id: PREDICTION_ID_VALUE",
    "X-Session-Id: SESSION_ID",
    "X-Store-Code: STORE_CODE",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/v2/merchants/orders/purchase"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("Cookie", "COOKIE_VALUE")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .header("X-Prediction-Id", "PREDICTION_ID_VALUE")
      .header("X-Session-Id", "SESSION_ID")
      .header("X-Store-Code", "STORE_CODE")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/v2/merchants/orders/purchase", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("Cookie", "COOKIE_VALUE")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")
  request.Header.Set("X-Prediction-Id", "PREDICTION_ID_VALUE")
  request.Header.Set("X-Session-Id", "SESSION_ID")
  request.Header.Set("X-Store-Code", "STORE_CODE")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/capture' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/capture", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/capture",
    headers={
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/capture",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/capture"))
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/capture", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/merchants/orders/{order_token}/void' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/merchants/orders/{order_token}/void", {
  method: "POST",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/merchants/orders/{order_token}/void",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/orders/{order_token}/void",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/orders/{order_token}/void"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/merchants/orders/{order_token}/void", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/refund' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/refund", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/refund",
    headers={
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/refund",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/refund"))
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/v2/merchants/orders/{order_token}/refund", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/users/register' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-Id: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/users/register", {
  method: "POST",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-Id": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/users/register",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-Id": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/register",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-Id: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/register"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/users/register", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/users/request-code' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/users/request-code", {
  method: "POST",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/users/request-code",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/request-code",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/request-code"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/users/request-code", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/users/login' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID' \
  --header 'X-Qa-Api-Key: QA_API_KEY_VALUE' \
  --header 'X-Recaptcha-Token: RECAPTCHA_TOKEN_VALUE' \
  --header 'X-Session-ID: SESSION_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/users/login", {
  method: "POST",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID",
    "X-Qa-Api-Key": "QA_API_KEY_VALUE",
    "X-Recaptcha-Token": "RECAPTCHA_TOKEN_VALUE",
    "X-Session-ID": "SESSION_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/users/login",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID",
        "X-Qa-Api-Key": "QA_API_KEY_VALUE",
        "X-Recaptcha-Token": "RECAPTCHA_TOKEN_VALUE",
        "X-Session-ID": "SESSION_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/login",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID",
    "X-Qa-Api-Key: QA_API_KEY_VALUE",
    "X-Recaptcha-Token: RECAPTCHA_TOKEN_VALUE",
    "X-Session-ID: SESSION_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/login"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .header("X-Qa-Api-Key", "QA_API_KEY_VALUE")
      .header("X-Recaptcha-Token", "RECAPTCHA_TOKEN_VALUE")
      .header("X-Session-ID", "SESSION_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/users/login", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")
  request.Header.Set("X-Qa-Api-Key", "QA_API_KEY_VALUE")
  request.Header.Set("X-Recaptcha-Token", "RECAPTCHA_TOKEN_VALUE")
  request.Header.Set("X-Session-ID", "SESSION_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/users/external-authorize' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Auth-Message: AUTH_MESSAGE_VALUE' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/users/external-authorize", {
  method: "POST",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Auth-Message": "AUTH_MESSAGE_VALUE",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/users/external-authorize",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Auth-Message": "AUTH_MESSAGE_VALUE",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/external-authorize",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Auth-Message: AUTH_MESSAGE_VALUE",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/external-authorize"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Auth-Message", "AUTH_MESSAGE_VALUE")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .method("POST", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/users/external-authorize", nil)
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Auth-Message", "AUTH_MESSAGE_VALUE")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/users/me' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/users/me", {
  method: "GET",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/users/me",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/me",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/me"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/users/me", nil)
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/users/{user_id}/addresses' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/users/{user_id}/addresses", {
  method: "GET",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/users/{user_id}/addresses",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/{user_id}/addresses",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/{user_id}/addresses"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/users/{user_id}/addresses", nil)
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/users/{user_id}/addresses' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/users/{user_id}/addresses", {
  method: "POST",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/users/{user_id}/addresses",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/{user_id}/addresses",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/{user_id}/addresses"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/users/{user_id}/addresses", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request PATCH \
  --url 'https://api.sandbox.deuna.io/users/{user_id}/addresses/{address_id}' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Device-Id: DEVICE_ID' \
  --header 'X-Merchant-Id: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/users/{user_id}/addresses/{address_id}", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Device-Id": "DEVICE_ID",
    "X-Merchant-Id": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "PATCH",
    "https://api.sandbox.deuna.io/users/{user_id}/addresses/{address_id}",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Device-Id": "DEVICE_ID",
        "X-Merchant-Id": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/{user_id}/addresses/{address_id}",
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Device-Id: DEVICE_ID",
    "X-Merchant-Id: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/{user_id}/addresses/{address_id}"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Device-Id", "DEVICE_ID")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("PATCH", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("PATCH", "https://api.sandbox.deuna.io/users/{user_id}/addresses/{address_id}", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Device-Id", "DEVICE_ID")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/v2/users/{user_id}/cards' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Merchant-ID: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/v2/users/{user_id}/cards", {
  method: "POST",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Merchant-ID": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/v2/users/{user_id}/cards",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Merchant-ID": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/v2/users/{user_id}/cards",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Merchant-ID: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/v2/users/{user_id}/cards"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/v2/users/{user_id}/cards", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/users/{user_id}/cards' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Merchant-ID: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/users/{user_id}/cards", {
  method: "GET",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Merchant-ID": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/users/{user_id}/cards",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Merchant-ID": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/{user_id}/cards",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Merchant-ID: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/{user_id}/cards"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/users/{user_id}/cards", nil)
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN'

const response = await fetch("https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}", {
  method: "GET",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}", nil)
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request PATCH \
  --url 'https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}/set-as-default' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'X-Merchant-ID: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}/set-as-default", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "X-Merchant-ID": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "PATCH",
    "https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}/set-as-default",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "X-Merchant-ID": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}/set-as-default",
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "X-Merchant-ID: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}/set-as-default"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("PATCH", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("PATCH", "https://api.sandbox.deuna.io/users/{user_id}/cards/{card_id}/set-as-default", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/cards/bin/{bin}' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-Id: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/cards/bin/{bin}", {
  method: "GET",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-Id": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/cards/bin/{bin}",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-Id": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/cards/bin/{bin}",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-Id: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/cards/bin/{bin}"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/cards/bin/{bin}", nil)
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/merchants/stores/payments-methods' \
  --header 'X-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Idempotency-Key: IDEMPOTENCY_KEY' \
  --header 'X-Merchant-Id: MERCHANT_ID' \
  --header 'X-Prediction-Id: PREDICTION_ID_VALUE' \
  --header 'X-Store-Code: STORE_CODE'

const response = await fetch("https://api.sandbox.deuna.io/merchants/stores/payments-methods", {
  method: "GET",
  headers: {
    "X-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Idempotency-Key": "IDEMPOTENCY_KEY",
    "X-Merchant-Id": "MERCHANT_ID",
    "X-Prediction-Id": "PREDICTION_ID_VALUE",
    "X-Store-Code": "STORE_CODE"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/merchants/stores/payments-methods",
    headers={
        "X-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Idempotency-Key": "IDEMPOTENCY_KEY",
        "X-Merchant-Id": "MERCHANT_ID",
        "X-Prediction-Id": "PREDICTION_ID_VALUE",
        "X-Store-Code": "STORE_CODE"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/stores/payments-methods",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "X-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Idempotency-Key: IDEMPOTENCY_KEY",
    "X-Merchant-Id: MERCHANT_ID",
    "X-Prediction-Id: PREDICTION_ID_VALUE",
    "X-Store-Code: STORE_CODE"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/stores/payments-methods"))
      .header("X-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Idempotency-Key", "IDEMPOTENCY_KEY")
      .header("X-Merchant-Id", "MERCHANT_ID")
      .header("X-Prediction-Id", "PREDICTION_ID_VALUE")
      .header("X-Store-Code", "STORE_CODE")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/merchants/stores/payments-methods", nil)
  if err != nil { panic(err) }
  request.Header.Set("X-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Idempotency-Key", "IDEMPOTENCY_KEY")
  request.Header.Set("X-Merchant-Id", "MERCHANT_ID")
  request.Header.Set("X-Prediction-Id", "PREDICTION_ID_VALUE")
  request.Header.Set("X-Store-Code", "STORE_CODE")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/merchants/payment-links' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/merchants/payment-links", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/merchants/payment-links",
    headers={
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/payment-links",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/payment-links"))
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/merchants/payment-links", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}'

const response = await fetch("https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}", {
  method: "GET"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}"))
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}", nil)
  if err != nil { panic(err) }

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/merchants/payment-links/all'

const response = await fetch("https://api.sandbox.deuna.io/merchants/payment-links/all", {
  method: "GET"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/merchants/payment-links/all",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/payment-links/all",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/payment-links/all"))
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/merchants/payment-links/all", nil)
  if err != nil { panic(err) }

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}/orders'

const response = await fetch("https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}/orders", {
  method: "GET"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}/orders",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}/orders",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}/orders"))
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/merchants/payment-links/{payment_link_id}/orders", nil)
  if err != nil { panic(err) }

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/subscriptions/plans' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'x-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-ID: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/subscriptions/plans", {
  method: "GET",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "x-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/subscriptions/plans",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "x-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-ID": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/subscriptions/plans",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "x-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/subscriptions/plans"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("x-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/subscriptions/plans", nil)
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("x-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/subscriptions/plans' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'x-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-ID: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/subscriptions/plans", {
  method: "POST",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "x-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/subscriptions/plans",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "x-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-ID": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/subscriptions/plans",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "x-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/subscriptions/plans"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("x-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/subscriptions/plans", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("x-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request GET \
  --url 'https://api.sandbox.deuna.io/subscriptions' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'x-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-ID: MERCHANT_ID'

const response = await fetch("https://api.sandbox.deuna.io/subscriptions", {
  method: "GET",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "x-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID": "MERCHANT_ID"
  }
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "GET",
    "https://api.sandbox.deuna.io/subscriptions",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "x-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-ID": "MERCHANT_ID"
    },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/subscriptions",
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "x-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID: MERCHANT_ID"
  ]
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/subscriptions"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("x-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .method("GET", HttpRequest.BodyPublishers.noBody())
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
)

func main() {
  request, err := http.NewRequest("GET", "https://api.sandbox.deuna.io/subscriptions", nil)
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("x-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request POST \
  --url 'https://api.sandbox.deuna.io/subscriptions' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'x-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-ID: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/subscriptions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "x-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://api.sandbox.deuna.io/subscriptions",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "x-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-ID": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/subscriptions",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "x-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/subscriptions"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("x-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://api.sandbox.deuna.io/subscriptions", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("x-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

curl --request PATCH \
  --url 'https://api.sandbox.deuna.io/subscriptions/{id}' \
  --header 'Authorization: Bearer USER_ACCESS_TOKEN' \
  --header 'x-Api-Key: YOUR_PRIVATE_API_KEY' \
  --header 'X-Merchant-ID: MERCHANT_ID' \
  --header 'Content-Type: application/json' \
  --data @request.json

const response = await fetch("https://api.sandbox.deuna.io/subscriptions/{id}", {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer USER_ACCESS_TOKEN",
    "x-Api-Key": "YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID": "MERCHANT_ID",
    "Content-Type": "application/json"
  },
  body: "@request.json"
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "PATCH",
    "https://api.sandbox.deuna.io/subscriptions/{id}",
    headers={
        "Authorization": "Bearer USER_ACCESS_TOKEN",
        "x-Api-Key": "YOUR_PRIVATE_API_KEY",
        "X-Merchant-ID": "MERCHANT_ID",
        "Content-Type": "application/json"
    },
    data="@request.json",
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.deuna.io/subscriptions/{id}",
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer USER_ACCESS_TOKEN",
    "x-Api-Key: YOUR_PRIVATE_API_KEY",
    "X-Merchant-ID: MERCHANT_ID",
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => "@request.json"
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.sandbox.deuna.io/subscriptions/{id}"))
      .header("Authorization", "Bearer USER_ACCESS_TOKEN")
      .header("x-Api-Key", "YOUR_PRIVATE_API_KEY")
      .header("X-Merchant-ID", "MERCHANT_ID")
      .header("Content-Type", "application/json")
      .method("PATCH", HttpRequest.BodyPublishers.ofString("@request.json"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("PATCH", "https://api.sandbox.deuna.io/subscriptions/{id}", strings.NewReader("@request.json"))
  if err != nil { panic(err) }
  request.Header.Set("Authorization", "Bearer USER_ACCESS_TOKEN")
  request.Header.Set("x-Api-Key", "YOUR_PRIVATE_API_KEY")
  request.Header.Set("X-Merchant-ID", "MERCHANT_ID")
  request.Header.Set("Content-Type", "application/json")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}