Take payments with four
lines of setup.

$result = $pay->createDeposit([
    'amount'            => 100,
    'customer_fullname' => 'Lorem Ipsum',
    'customer_username' => 'user_42',
    'customer_id'       => 'CUST-789456',
    'customer_site'     => 'example.com',       // optional
    'customer_email'    => '[email protected]',  // optional
    'order_id'          => 'ORD-1001',          // optional
]);

if ($result->created()) {
    $this->showBank(
        $result->bank->accountIban,
        $result->bank->accountHolder,
        $result->bank->amount
    );
    $this->save($result->transactionId());
} else {
    $this->showToCustomer($result->customerMessage());
}

const result = await pay.createDeposit({
  amount: 100,
  customer_fullname: 'Lorem Ipsum',
  customer_username: 'user_42',
  customer_id: 'CUST-789456',
  customer_site: 'example.com',       // optional
  customer_email: '[email protected]', // optional
  order_id: 'ORD-1001',               // optional
});

if (result.created) {
  showBank(
    result.bank.accountIban,
    result.bank.accountHolder,
    result.bank.amount
  );
  save(result.transactionId);
} else {
  showToCustomer(result.customerMessage);
}

var result = await pay.CreateDepositAsync(new DepositRequest
{
    Amount           = 100,
    CustomerFullname = "Lorem Ipsum",
    CustomerUsername = "user_42",
    CustomerId       = "CUST-789456",
    CustomerSite     = "example.com",       // optional
    CustomerEmail    = "[email protected]",  // optional
    OrderId          = "ORD-1001",          // optional
});

if (result.Created)
{
    ShowBank(
        result.Bank.AccountIban,
        result.Bank.AccountHolder,
        result.Bank.Amount);
    Save(result.TransactionId);
}
else
{
    ShowToCustomer(result.CustomerMessage);
}

$result = $pay->createWithdraw([
    'amount'            => 1000,
    'customer_fullname' => 'Lorem Ipsum',
    'customer_username' => 'user_42',
    'customer_id'       => 'CUST-789456',
    'account_iban'      => 'TR580006400000143750001552',  // TEST IBAN — never in production
    'account_holder'    => 'Lorem Ipsum',
    'customer_site'     => 'example.com',  // optional
    'order_id'          => 'ORD-1002',     // optional
]);

if (!$result->created()) {
    $this->showToCustomer($result->customerMessage());
}

const result = await pay.createWithdraw({
  amount: 1000,
  customer_fullname: 'Lorem Ipsum',
  customer_username: 'user_42',
  customer_id: 'CUST-789456',
  account_iban: 'TR580006400000143750001552',  // TEST IBAN — never in production
  account_holder: 'Lorem Ipsum',
  customer_site: 'example.com',  // optional
  order_id: 'ORD-1002',          // optional
});

if (!result.created) {
  showToCustomer(result.customerMessage);
}

var result = await pay.CreateWithdrawAsync(new WithdrawRequest
{
    Amount           = 1000,
    CustomerFullname = "Lorem Ipsum",
    CustomerUsername = "user_42",
    CustomerId       = "CUST-789456",
    AccountIban      = "TR580006400000143750001552",  // TEST IBAN — never in production
    AccountHolder    = "Lorem Ipsum",
    CustomerSite     = "example.com",  // optional
    OrderId          = "ORD-1002",     // optional
});

if (!result.Created)
{
    ShowToCustomer(result.CustomerMessage);
}

$result = $pay->checkDeposit('32c0ceb7-37b0-4ab4-8ab5-6e53debecac6');
// or: $pay->check($transactionId, 'withdraw');

if (!$result->found()) {
    $this->log('unknown transaction');
} elseif ($result->statusValue === TransactionStatus::APPROVED) {
    $this->settle($result->finalAmount);
} else {
    $this->log($result->statusValue, TransactionStatus::label($result->statusValue));
}

const result = await pay.checkDeposit('32c0ceb7-37b0-4ab4-8ab5-6e53debecac6');
// or: pay.check(transactionId, 'withdraw');

if (!result.found) {
  log('unknown transaction');
} else if (result.statusValue === TransactionStatus.APPROVED) {
  settle(result.finalAmount);
} else {
  log(result.statusValue, TransactionStatus.label(result.statusValue));
}

var result = await pay.CheckDepositAsync("32c0ceb7-37b0-4ab4-8ab5-6e53debecac6");
// or: await pay.CheckAsync(transactionId, Operation.Withdraw);

if (!result.Found)
    Log("unknown transaction");
else if (result.StatusValue == TransactionStatus.Approved)
    Settle(result.FinalAmount);
else
    Log(result.StatusValue, TransactionStatus.Label(result.StatusValue));

$result = $pay->cancel('56f07728-259e-47d5-9c28-3b5e071178ec');

if ($result->succeeded()) {
    $this->markCancelled($result->previousStatus);  // PAY_NEW or PAY_PROCESSING
} elseif ($result->notCancellable()) {
    $this->log('already final: ' . $result->statusValue);
} else {
    $this->log($result->message);  // under review, busy, or not found
}

const result = await pay.cancel('56f07728-259e-47d5-9c28-3b5e071178ec');

if (result.succeeded) {
  markCancelled(result.previousStatus);  // PAY_NEW or PAY_PROCESSING
} else if (result.notCancellable) {
  log('already final:', result.statusValue);
} else {
  log(result.message);  // under review, busy, or not found
}

var result = await pay.CancelAsync("56f07728-259e-47d5-9c28-3b5e071178ec");

if (result.Succeeded)
    MarkCancelled(result.PreviousStatus);  // PAY_NEW or PAY_PROCESSING
else if (result.NotCancellable)
    Log($"already final: {result.StatusValue}");
else
    Log(result.Message);  // under review, busy, or not found

// Laravel
use EkstraPay\EkstraPay;
use EkstraPay\SignatureException;

public function depositCallback(Request $request)
{
    $pay = app(EkstraPay::class);

    try {
        $event = $pay->parseCallback($request->all());
    } catch (SignatureException $e) {
        return response()->json(['status' => false, 'message' => 'Invalid hash'], 400);
    }

    // the same callback can arrive twice — keep this idempotent
    if ($event->isApproved()) {
        $this->creditCustomer($event->customerId, $event->requestFinalAmount);
    } else {
        $this->recordStatus($event->transactionId, $event->status);
    }

    return response()->json(EkstraPay::callbackResponse());
}

// Express
const express = require('express');
const { EkstraPay, SignatureError } = require('./ekstrapay');

const app = express();
app.use(express.json());
const pay = new EkstraPay(KEY, SECRET);

app.post('/callbacks/ekstrapay/deposit', (req, res) => {
  let event;
  try {
    event = pay.parseCallback(req.body);
  } catch (err) {
    if (err instanceof SignatureError) {
      return res.status(400).json({ status: false, message: 'Invalid hash' });
    }
    throw err;
  }

  // the same callback can arrive twice — keep this idempotent
  if (event.isApproved) {
    creditCustomer(event.customerId, event.requestFinalAmount);
  } else {
    recordStatus(event.transactionId, event.status);
  }

  res.json(EkstraPay.callbackResponse());
});

// ASP.NET Core
[ApiController]
[Route("callbacks/ekstrapay")]
public class EkstraPayCallbackController : ControllerBase
{
    private readonly EkstraPayClient _pay;
    public EkstraPayCallbackController(EkstraPayClient pay) => _pay = pay;

    [HttpPost("deposit")]
    public IActionResult Deposit([FromBody] JsonNode payload)
    {
        CallbackEvent evt;
        try
        {
            evt = _pay.ParseCallback(payload);
        }
        catch (SignatureException)
        {
            return BadRequest(new { status = false, message = "Invalid hash" });
        }

        // the same callback can arrive twice — keep this idempotent
        if (evt.IsApproved)
            CreditCustomer(evt.CustomerId, evt.RequestFinalAmount);
        else
            RecordStatus(evt.TransactionId, evt.Status);

        return Ok(EkstraPayClient.CallbackResponse());
    }
}