We Turn Complex Workflows
Into Elegant Software.

using PayBridge;
using PayBridge.Models.Requests;

var client = new PayBridgeClient();

var store = await client.Stores.RegisterAsync(new RegisterStoreRequest
{
    Name = "My Awesome Store",
    WebhookUrl = "https://yourapp.com/webhooks/paybridge"
});

var storeId = store.Id;
var apiKey  = store.ApiKey;
client.SetApiKey(apiKey);

var payment = await _payments.CreateIntentAsync(new CreatePaymentIntentRequest
{
    StoreId     = storeId.ToString(),
    OrderId     = "ORDER-1001",
    AmountMinor = 49900,
    Currency    = "INR",
    ProviderCode = "razorpay",
    ReturnUrl   = "https://yourapp.com/payment/success",
    CancelUrl   = "https://yourapp.com/payment/cancel"
});

var confirmed = await _payments.ConfirmAsync(payment.PaymentId, new ConfirmPaymentRequest { });
var captured  = await _payments.CaptureAsync(payment.PaymentId, new CapturePaymentRequest { AmountMinor = 49900 });

async function processPayment(apiResponse) {
  const config = apiResponse.frontendConfig;

  if (config.provider === "PayU") {
    const form = document.createElement("form");
    form.method = "POST";
    form.action = config.sdkOptions.post_url;
    Object.keys(config.sdkOptions).forEach(key => {
      if (key === "post_url") return;
      const input = document.createElement("input");
      input.type = "hidden"; input.name = key;
      input.value = config.sdkOptions[key] ?? "";
      form.appendChild(input);
    });
    document.body.appendChild(form); form.submit();
    return;
  }

  if (config.flowType === "redirect" && config.approvalUrl) {
    window.location.href = config.approvalUrl;
    return;
  }

  await loadScript(config.sdkScriptUrl);

  switch (config.provider) {
    case "Razorpay": {
      const rzp = new Razorpay({
        key:      config.publicKey,
        order_id: config.sdkOptions?.order_id,
        amount:   config.sdkOptions?.amount,
        currency: config.sdkOptions?.currency,
        handler:  (r) => console.log("Razorpay success", r)
      });
      rzp.open();
      break;
    }
    case "Stripe": {
      const stripe   = Stripe(config.publicKey);
      const elements = stripe.elements({ clientSecret: config.clientSecret });
      const el       = elements.create("payment");
      el.mount("#payment-element");
      break;
    }
  }
}

using PayBridge.Exceptions;

try
{
    var refund = await _payments.RefundAsync(payment.PaymentId, new RefundPaymentRequest
    {
        AmountMinor = 49900,
        Reason = "Customer requested refund"
    });
}
catch (PayBridgeValidationException ex) { }
catch (PayBridgeException ex)           { }

app.MapPost("/webhooks/paybridge", async (
    HttpRequest request, IWebhooksService webhooks, IConfiguration cfg) =>
{
    var body = await new StreamReader(request.Body).ReadToEndAsync();
    var sig  = request.Headers["X-Signature"].ToString();

    if (!webhooks.ValidateSignature(body, sig, cfg["PayBridge:WebhookSecret"]!))
        return Results.Unauthorized();

    var evt = webhooks.ParseEvent(body);
    return Results.Ok();
});