curl "https://ipg.irandargah.com/v2/payments" \
  -H "Authorization: Bearer idg_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"

<?php
$headers = [
    'Authorization: Bearer idg_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx',
    'Content-Type: application/json',
];

const headers = {
  Authorization: "Bearer idg_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "Content-Type": "application/json",
};

req.Header.Set("Authorization", "Bearer idg_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx")
req.Header.Set("Content-Type", "application/json")

headers = {
    'Authorization': 'Bearer idg_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx',
    'Content-Type':  'application/json',
}

client.DefaultRequestHeaders.Add("Authorization", "Bearer idg_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx");

curl -X GET "https://ipg.irandargah.com/v2/idempotency-key"

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/idempotency-key");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$result = json_decode($response, true);
$idempotencyKey = $result['idempotency_key'];
?>

fetch("https://ipg.irandargah.com/v2/idempotency-key")
  .then((response) => response.json())
  .then((data) => {
    const idempotencyKey = data.idempotency_key;
    console.log("Idempotency Key:", idempotencyKey);
  });

resp, err := http.Get("https://ipg.irandargah.com/v2/idempotency-key")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
idempotencyKey := result["idempotency_key"].(string)

import requests

response = requests.get('https://ipg.irandargah.com/v2/idempotency-key')
data = response.json()
idempotency_key = data['idempotency_key']

using var client = new HttpClient();
var response = await client.GetAsync("https://ipg.irandargah.com/v2/idempotency-key");
var json = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject<dynamic>(json);
string idempotencyKey = result.idempotency_key;

{
  "success": true,
  "idempotency_key": "txn_1a2b3c4d5e6f7g8h9i0j",
  "expires_in": 86400,
  "usage": "Include this key in the Idempotency-Key header for your payment request"
}

curl -X POST "https://ipg.irandargah.com/v2/payments" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: unique-key-123" \
  -d '{
    "amount": 100000,
    "order_id": "ORDER-12345",
    "callback_url": "https://merchant.com/callback",
    "description": "خرید محصول آزمایشی",
    "mobile": "09123456789"
  }'

<?php
$data = [
    'amount' => 100000,
    'order_id' => 'ORDER-12345',
    'callback_url' => 'https://merchant.com/callback',
    'description' => 'خرید محصول آزمایشی',
    'mobile' => '09123456789'
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/payments");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_TOKEN",
    "Content-Type: application/json",
    "Idempotency-Key: unique-key-123"
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$result = json_decode($response, true);
?>

const payment = {
  amount: 100000,
  order_id: "ORDER-12345",
  callback_url: "https://merchant.com/callback",
  description: "خرید محصول آزمایشی",
  mobile: "09123456789",
};

const response = await fetch("https://ipg.irandargah.com/v2/payments", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_TOKEN",
    "Content-Type": "application/json",
    "Idempotency-Key": "unique-key-123",
  },
  body: JSON.stringify(payment),
});

const data = await response.json();
console.log(data);

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type PaymentRequest struct {
    Amount      int    `json:"amount"`
    OrderID     string `json:"order_id"`
    CallbackURL string `json:"callback_url"`
    Description string `json:"description"`
    Mobile      string `json:"mobile"`
}

func main() {
    payment := PaymentRequest{
        Amount:      100000,
        OrderID:     "ORDER-12345",
        CallbackURL: "https://merchant.com/callback",
        Description: "خرید محصول آزمایشی",
        Mobile:      "09123456789",
    }

    jsonData, _ := json.Marshal(payment)

    req, _ := http.NewRequest("POST", "https://ipg.irandargah.com/v2/payments", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Idempotency-Key", "unique-key-123")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
}

import requests
import json

payment_data = {
    'amount': 100000,
    'order_id': 'ORDER-12345',
    'callback_url': 'https://merchant.com/callback',
    'description': 'خرید محصول آزمایشی',
    'mobile': '09123456789'
}

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN',
    'Content-Type': 'application/json',
    'Idempotency-Key': 'unique-key-123'
}

response = requests.post(
    'https://ipg.irandargah.com/v2/payments',
    headers=headers,
    json=payment_data
)

result = response.json()
print(result)

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class PaymentRequest
{
    [JsonProperty("amount")]
    public int Amount { get; set; }

    [JsonProperty("order_id")]
    public string OrderId { get; set; }

    [JsonProperty("callback_url")]
    public string CallbackUrl { get; set; }

    [JsonProperty("description")]
    public string Description { get; set; }

    [JsonProperty("mobile")]
    public string Mobile { get; set; }
}

public async Task<string> CreatePaymentAsync()
{
    var payment = new PaymentRequest
    {
        Amount = 100000,
        OrderId = "ORDER-12345",
        CallbackUrl = "https://merchant.com/callback",
        Description = "خرید محصول آزمایشی",
        Mobile = "09123456789"
    };

    using var client = new HttpClient();
    client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");
    client.DefaultRequestHeaders.Add("Idempotency-Key", "unique-key-123");

    var json = JsonConvert.SerializeObject(payment);
    var content = new StringContent(json, Encoding.UTF8, "application/json");

    var response = await client.PostAsync("https://ipg.irandargah.com/v2/payments", content);
    return await response.Content.ReadAsStringAsync();
}

{
  "success": true,
  "data": {
    "transaction": {
      "authority": "2025100121424146HC",
      "gateway_url": "https://ipg.irandargah.com/startpay/2025100121424146HC",
      "expires_at": "1404-06-28 10:50:00"
    },
    "meta": {
      "idempotency_key": "unique-key-123",
      "request_id": "65a4c7e8f1234",
      "processing_time_ms": 45
    }
  },
  "message": "تراکنش با موفقیت ایجاد شد",
  "status_code": 100,
  "timestamp": "1404-06-28 10:30:00"
}

curl "https://ipg.irandargah.com/v2/payments/2025100121424146HC" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$authority = '2025100121424146HC';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/payments/{$authority}");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const authority = "2025100121424146HC";

const response = await fetch(
  `https://ipg.irandargah.com/v2/payments/${authority}`,
  {
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

const data = await response.json();

authority := "2025100121424146HC"
url := fmt.Sprintf("https://ipg.irandargah.com/v2/payments/%s", authority)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

client := &http.Client{}
resp, err := client.Do(req)

authority = '2025100121424146HC'

response = requests.get(
    f'https://ipg.irandargah.com/v2/payments/{authority}',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

result = response.json()

string authority = "2025100121424146HC";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.GetAsync($"https://ipg.irandargah.com/v2/payments/{authority}");
var content = await response.Content.ReadAsStringAsync();

{
  "success": true,
  "data": {
    "transaction": {
      "authority": "2025100121424146HC",
      "ref_id": "2025100121424146HC",
      "amount": 100000,
      "status": "completed",
      "created_at": "1404-06-28 10:30:00",
      "updated_at": "1404-06-28 10:35:00"
    },
    "meta": {
      "request_id": "65a4c7e8f1234",
      "cached": false
    }
  },
  "message": "اطلاعات تراکنش با موفقیت دریافت شد",
  "status_code": 200,
  "timestamp": "1404-06-28 10:35:00"
}

curl -X POST "https://ipg.irandargah.com/v2/payments/2025100121424146HC/cancel" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$authority = '2025100121424146HC';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/payments/{$authority}/cancel");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const authority = "2025100121424146HC";

const response = await fetch(
  `https://ipg.irandargah.com/v2/payments/${authority}/cancel`,
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

authority := "2025100121424146HC"
url := fmt.Sprintf("https://ipg.irandargah.com/v2/payments/%s/cancel", authority)

req, _ := http.NewRequest("POST", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

client := &http.Client{}
resp, err := client.Do(req)

authority = '2025100121424146HC'

response = requests.post(
    f'https://ipg.irandargah.com/v2/payments/{authority}/cancel',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

string authority = "2025100121424146HC";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.PostAsync($"https://ipg.irandargah.com/v2/payments/{authority}/cancel", null);

{
  "success": true,
  "data": {
    "transaction": {
      "authority": "2025100121424146HC",
      "ref_id": null,
      "amount": 100000,
      "status": "completed",
      "created_at": "1404-06-28 10:30:00",
      "updated_at": "1404-06-28 10:35:00"
    },
    "meta": {
      "request_id": "65a4c7e8f1234",
      "cached": false
    }
  },
  "message": "پرداخت با موفقیت لغو شد",
  "status_code": 200,
  "timestamp": "1404-06-28 10:35:00"
}

https://yoursite.com/callback?
  authority=2025100121424146HC&
  status_code=201&
  message=پرداخت+در+انتظار+تایید+است&
  amount=100000&
  order_id=ORDER-12345&
  ref_id=123456789&
  card_pan=603799******1234

<?php
// Laravel - V2 Callback Handler (snake_case)
Route::any('/callback', function (Request $request) {
    // دریافت پارامترهای callback - تمام فیلدها snake_case هستند
    $callbackData = [
        'authority'   => $request->input('authority'),
        'status_code' => (int) $request->input('status_code'),
        'message'     => $request->input('message'),
        'amount'      => (int) $request->input('amount'),
        'order_id'    => $request->input('order_id'),
        'ref_id'      => $request->input('ref_id'),
        'card_pan'    => $request->input('card_pan'),
    ];

    // بررسی وضعیت پرداخت
    // کد 201 = پرداخت موفق، منتظر تأیید (حالت معمول)
    // کد 100 = پرداخت و تأیید موفق (حالت direct_verify=true)
    if (in_array($callbackData['status_code'], [201, 100])) {
        // پرداخت موفق - تأیید با API (در حالت direct_verify=false)
        $response = Http::withToken(env('API_TOKEN'))
            ->post('https://ipg.irandargah.com/v2/verifications', [
                'authority' => $callbackData['authority'],
                'amount'    => $callbackData['amount'],
            ]);

        $result = $response->json();

        if ($result['success']) {
            $ref_id = $result['data']['verification']['ref_id'];

            // به‌روزرسانی وضعیت سفارش
            Order::where('order_id', $callbackData['order_id'])
                ->update([
                    'status'    => 'paid',
                    'ref_id'    => $ref_id,
                    'card_pan'  => $callbackData['card_pan'],
                ]);

            return view('payment.success', ['ref_id' => $ref_id]);
        }
    }

    // پرداخت ناموفق
    return view('payment.failed', [
        'status_code' => $callbackData['status_code']
    ]);
});
?>

// Node.js/Express - V2 Callback Handler (snake_case)
app.all("/callback", async (req, res) => {
  // پارامترها از body یا query string دریافت می‌شوند (بسته به action)
  const params = { ...req.query, ...req.body };
  const { authority, status_code, message, amount, order_id, ref_id, card_pan } = params;

  // کد 201 = موفق (منتظر تأیید)، کد 100 = موفق (تأیید شده)
  if (parseInt(status_code) === 201 || parseInt(status_code) === 100) {
    // Verify payment with API
    const response = await fetch(
      "https://ipg.irandargah.com/v2/verifications",
      {
        method: "POST",
        headers: {
          Authorization: "Bearer YOUR_API_TOKEN",
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          authority,
          amount: parseInt(amount),
        }),
      }
    );

    const result = await response.json();

    if (result.success) {
      // Update order status in database
      await Order.update(
        {
          status:   "paid",
          ref_id:   result.data.verification.ref_id,
          card_pan: card_pan,
        },
        { where: { order_id } }
      );

      return res.render("success", {
        ref_id: result.data.verification.ref_id,
      });
    }
  }

  res.render("failed", { status_code });
});

# Python/Django - V2 Callback Handler (snake_case)
from django.shortcuts import render
import requests

def payment_callback(request):
    # دریافت پارامترهای callback (GET یا POST بسته به action)
    params = request.POST if request.method == 'POST' else request.GET
    callback_data = {
        'authority':   params.get('authority'),
        'status_code': int(params.get('status_code', -1)),
        'message':     params.get('message'),
        'amount':      int(params.get('amount', 0)),
        'order_id':    params.get('order_id'),
        'ref_id':      params.get('ref_id'),
        'card_pan':    params.get('card_pan'),
    }

    # کد 201 = موفق (منتظر تأیید)، کد 100 = موفق (تأیید شده)
    if callback_data['status_code'] in [201, 100]:
        # تأیید پرداخت با API
        response = requests.post(
            'https://ipg.irandargah.com/v2/verifications',
            headers={'Authorization': 'Bearer YOUR_API_TOKEN'},
            json={
                'authority': callback_data['authority'],
                'amount':    callback_data['amount']
            }
        )

        result = response.json()

        if result['success']:
            # به‌روزرسانی سفارش
            Order.objects.filter(order_id=callback_data['order_id']).update(
                status='paid',
                ref_id=result['data']['verification']['ref_id'],
                card_pan=callback_data['card_pan']
            )

            return render(request, 'payment/success.html', {
                'ref_id': result['data']['verification']['ref_id']
            })

    return render(request, 'payment/failed.html', {
        'status_code': callback_data['status_code']
    })

curl -X POST "https://ipg.irandargah.com/v2/verifications" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: verification-key-123" \
  -d '{
    "authority": "2025100121424146HC",
    "amount": 100000
  }'

<?php
$data = [
    'authority' => '2025100121424146HC',
    'amount' => 100000
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/verifications");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_TOKEN",
    "Content-Type: application/json",
    "Idempotency-Key: verification-key-123"
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

$result = json_decode($response, true);
?>

const verification = {
  authority: "2025100121424146HC",
  amount: 100000,
};

const response = await fetch("https://ipg.irandargah.com/v2/verifications", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_TOKEN",
    "Content-Type": "application/json",
    "Idempotency-Key": "verification-key-123",
  },
  body: JSON.stringify(verification),
});

const data = await response.json();

type VerificationRequest struct {
    Authority string `json:"authority"`
    Amount    int    `json:"amount"`
}

func verifyPayment() {
    verification := VerificationRequest{
        Authority: "2025100121424146HC",
        Amount:    100000,
    }

    jsonData, _ := json.Marshal(verification)

    req, _ := http.NewRequest("POST", "https://ipg.irandargah.com/v2/verifications", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Idempotency-Key", "verification-key-123")

    client := &http.Client{}
    resp, err := client.Do(req)
}

verification_data = {
    'authority': '2025100121424146HC',
    'amount': 100000
}

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN',
    'Content-Type': 'application/json',
    'Idempotency-Key': 'verification-key-123'
}

response = requests.post(
    'https://ipg.irandargah.com/v2/verifications',
    headers=headers,
    json=verification_data
)

result = response.json()

public class VerificationRequest
{
    [JsonProperty("authority")]
    public string Authority { get; set; }

    [JsonProperty("amount")]
    public int Amount { get; set; }
}

var verification = new VerificationRequest
{
    Authority = "2025100121424146HC",
    Amount = 100000
};

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");
client.DefaultRequestHeaders.Add("Idempotency-Key", "verification-key-123");

var json = JsonConvert.SerializeObject(verification);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync("https://ipg.irandargah.com/v2/verifications", content);

{
  "success": true,
  "data": {
    "verification": {
      "ref_id": "123456789",
      "authority": "2025100121424146HC",
      "amount": 100000,
      "verified_at": "1404-06-28 10:35:00"
    },
    "meta": {
      "request_id": "req_verify_001",
      "processing_time_ms": 85
    }
  },
  "message": "تراکنش با موفقیت تأیید شد",
  "status_code": 200,
  "timestamp": "1404-06-28 10:35:00"
}

curl "https://ipg.irandargah.com/v2/verifications/2025100121424146HC" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$authority = '2025100121424146HC';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/verifications/{$authority}");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const authority = "2025100121424146HC";

const response = await fetch(
  `https://ipg.irandargah.com/v2/verifications/${authority}`,
  {
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

const data = await response.json();

authority := "2025100121424146HC"
url := fmt.Sprintf("https://ipg.irandargah.com/v2/verifications/%s", authority)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

client := &http.Client{}
resp, err := client.Do(req)

authority = '2025100121424146HC'

response = requests.get(
    f'https://ipg.irandargah.com/v2/verifications/{authority}',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

result = response.json()

string authority = "2025100121424146HC";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.GetAsync($"https://ipg.irandargah.com/v2/verifications/{authority}");
var content = await response.Content.ReadAsStringAsync();

{
  "success": true,
  "data": {
    "verification": {
      "ref_id": "123456789",
      "authority": "2025100121424146HC",
      "amount": 100000,
      "verified_at": "1404-06-28 10:35:00"
    },
    "meta": {
      "request_id": "req_status_001"
    }
  },
  "message": "اطلاعات تراکنش با موفقیت دریافت شد",
  "status_code": 200,
  "timestamp": "1404-06-28 10:40:00"
}

curl -X POST "https://ipg.irandargah.com/v2/verifications/2025100121424146HC/retry" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$authority = '2025100121424146HC';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/verifications/{$authority}/retry");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const authority = "2025100121424146HC";

const response = await fetch(
  `https://ipg.irandargah.com/v2/verifications/${authority}/retry`,
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

authority := "2025100121424146HC"
url := fmt.Sprintf("https://ipg.irandargah.com/v2/verifications/%s/retry", authority)

req, _ := http.NewRequest("POST", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

client := &http.Client{}
resp, err := client.Do(req)

authority = '2025100121424146HC'

response = requests.post(
    f'https://ipg.irandargah.com/v2/verifications/{authority}/retry',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

string authority = "2025100121424146HC";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.PostAsync($"https://ipg.irandargah.com/v2/verifications/{authority}/retry", null);

{
  "success": true,
  "data": {
    "verification": {
      "ref_id": "123456789",
      "authority": "2025100121424146HC",
      "amount": 100000,
      "verified_at": "1404-06-28 10:45:00"
    },
    "meta": {
      "request_id": "req_retry_001",
      "processing_time_ms": 120
    }
  },
  "message": "تأیید مجدد با موفقیت انجام شد",
  "status_code": 200,
  "timestamp": "1404-06-28 10:45:00"
}

curl "https://ipg.irandargah.com/v2/transactions?page=1&per_page=10&status=completed&from_date=1404-06-01&to_date=1404-06-31" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$query = http_build_query([
    'page'      => 1,
    'per_page'  => 10,
    'status'    => 'completed',
    'from_date' => '1404-06-01',
    'to_date'   => '1404-06-31',
]);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/transactions?{$query}");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const params = new URLSearchParams({
  page:      1,
  per_page:  10,
  status:    "completed",
  from_date: "1404-06-01",
  to_date:   "1404-06-31",
});

const response = await fetch(
  `https://ipg.irandargah.com/v2/transactions?${params}`,
  {
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

params := url.Values{}
params.Add("page", "1")
params.Add("per_page", "10")
params.Add("status", "completed")
params.Add("from_date", "1404-06-01")
params.Add("to_date", "1404-06-31")

url := fmt.Sprintf("https://ipg.irandargah.com/v2/transactions?%s", params.Encode())

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

params = {
    'page':      1,
    'per_page':  10,
    'status':    'completed',
    'from_date': '1404-06-01',
    'to_date':   '1404-06-31',
}

response = requests.get(
    'https://ipg.irandargah.com/v2/transactions',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'},
    params=params
)

var query = "?page=1&per_page=10&status=completed&from_date=1404-06-01&to_date=1404-06-31";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.GetAsync($"https://ipg.irandargah.com/v2/transactions{query}");

{
  "success": true,
  "data": {
    "transactions": [
      {
        "authority": "2025100121424146HC",
        "amount": 100000,
        "status": "completed",
        "order_id": "ORDER-12345",
        "ref_code": "2025100121424146HC",
        "created_at": "1404-06-28 10:30:00",
        "verified_at": "1404-06-28 10:45:00"
      }
    ],
    "pagination": {
      "current_page": 1,
      "per_page": 10,
      "total": 1,
      "last_page": 1
    }
  },
  "timestamp": "1404-06-28 10:45:00"
}

curl "https://ipg.irandargah.com/v2/transactions/2025100121424146HC" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$authority = '2025100121424146HC';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/transactions/{$authority}");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const authority = "2025100121424146HC";

const response = await fetch(
  `https://ipg.irandargah.com/v2/transactions/${authority}`,
  {
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

authority := "2025100121424146HC"
url := fmt.Sprintf("https://ipg.irandargah.com/v2/transactions/%s", authority)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

authority = '2025100121424146HC'

response = requests.get(
    f'https://ipg.irandargah.com/v2/transactions/{authority}',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

string authority = "2025100121424146HC";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.GetAsync($"https://ipg.irandargah.com/v2/transactions/{authority}");

{
  "success": true,
  "data": {
    "transaction": {
      "authority": "2025100121424146HC",
      "order_id": "ORDER-12345",
      "amount": 100000,
      "status": "completed",
      "workflow_state": "COMPLETED",
      "description": "خرید محصول آزمایشی",
      "ref_code": "2025100121424146HC",
      "callback_url": "https://merchant.com/callback",
      "created_at": "1404-06-28 10:30:00",
      "updated_at": "1404-06-28 10:35:00",
      "expires_at": "1404-06-28 10:50:00",
      "is_expired": false,
      "can_be_verified": false,
      "verification_status": 200
    }
  },
  "timestamp": "1404-06-28 11:00:00"
}

curl "https://ipg.irandargah.com/health"

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/health");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const response = await fetch("https://ipg.irandargah.com/health");
const data = await response.json();

resp, err := http.Get("https://ipg.irandargah.com/health")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

response = requests.get('https://ipg.irandargah.com/health')
result = response.json()

using var client = new HttpClient();
var response = await client.GetAsync("https://ipg.irandargah.com/health");
var content = await response.Content.ReadAsStringAsync();

{
  "status": "ok",
  "timestamp": "1404-06-29 10:30:00",
  "version": "2.0.0"
}

curl -X POST "https://ipg.irandargah.com/v2/webhooks/subscribe" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://merchant.com/webhook",
    "events": ["payment.completed", "payment.failed"],
    "secret": "your_optional_secret_min_8_chars",
    "description": "وب‌هوک اصلی فروشگاه"
  }'

<?php
$data = [
    'url'         => 'https://merchant.com/webhook',
    'events'      => ['payment.completed', 'payment.failed'],
    'secret'      => 'your_optional_secret_min_8_chars', // اختیاری
    'description' => 'وب‌هوک اصلی فروشگاه',              // اختیاری
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/webhooks/subscribe");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_TOKEN",
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data, JSON_UNESCAPED_UNICODE));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const webhook = {
  url: "https://merchant.com/webhook",
  events: ["payment.completed", "payment.failed"],
  secret: "your_optional_secret_min_8_chars", // اختیاری
  description: "وب‌هوک اصلی فروشگاه", // اختیاری
};

const response = await fetch(
  "https://ipg.irandargah.com/v2/webhooks/subscribe",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify(webhook),
  },
);

type WebhookSubscription struct {
    URL         string   `json:"url"`
    Events      []string `json:"events"`
    Secret      string   `json:"secret,omitempty"`
    Description string   `json:"description,omitempty"`
}

webhook := WebhookSubscription{
    URL:         "https://merchant.com/webhook",
    Events:      []string{"payment.completed", "payment.failed"},
    Secret:      "your_optional_secret_min_8_chars",
    Description: "وب‌هوک اصلی فروشگاه",
}

jsonData, _ := json.Marshal(webhook)

req, _ := http.NewRequest("POST", "https://ipg.irandargah.com/v2/webhooks/subscribe", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")
req.Header.Set("Content-Type", "application/json")

webhook_data = {
    'url':         'https://merchant.com/webhook',
    'events':      ['payment.completed', 'payment.failed'],
    'secret':      'your_optional_secret_min_8_chars',  # اختیاری
    'description': 'وب‌هوک اصلی فروشگاه',                # اختیاری
}

response = requests.post(
    'https://ipg.irandargah.com/v2/webhooks/subscribe',
    headers={
        'Authorization': 'Bearer YOUR_API_TOKEN',
        'Content-Type':  'application/json',
    },
    json=webhook_data
)

public class WebhookSubscription
{
    public string Url { get; set; }
    public List<string> Events { get; set; }
    public string Secret { get; set; }       // اختیاری
    public string Description { get; set; }  // اختیاری
}

var webhook = new WebhookSubscription
{
    Url         = "https://merchant.com/webhook",
    Events      = new List<string> { "payment.completed", "payment.failed" },
    Secret      = "your_optional_secret_min_8_chars",
    Description = "وب‌هوک اصلی فروشگاه",
};

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var json    = JsonConvert.SerializeObject(webhook);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync("https://ipg.irandargah.com/v2/webhooks/subscribe", content);

{
  "success": true,
  "data": {
    "webhook": {
      "id": "65a4c7e8f1234",
      "url": "https://merchant.com/webhook",
      "events": ["payment.completed", "payment.failed"],
      "secret": "***masked***",
      "is_active": true,
      "created_at": "1404-06-29 10:30:00"
    }
  },
  "message": "Webhook subscription created successfully",
  "timestamp": "1404-06-29 10:30:00"
}

curl "https://ipg.irandargah.com/v2/webhooks/events" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/webhooks/events");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

$events = json_decode($response, true)['data']['events'];
?>

const response = await fetch("https://ipg.irandargah.com/v2/webhooks/events", {
  headers: { Authorization: "Bearer YOUR_API_TOKEN" },
});

const { data } = await response.json();
console.log(data.events);

req, _ := http.NewRequest("GET", "https://ipg.irandargah.com/v2/webhooks/events", nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil { log.Fatal(err) }
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)

response = requests.get(
    'https://ipg.irandargah.com/v2/webhooks/events',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

events = response.json()['data']['events']

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.GetAsync("https://ipg.irandargah.com/v2/webhooks/events");
var content  = await response.Content.ReadAsStringAsync();

{
  "success": true,
  "data": {
    "events": {
      "payment.created": "Triggered when a new payment is initiated",
      "payment.completed": "Triggered when a payment is successfully completed",
      "...": "..."
    },
    "webhook_requirements": {
      "url": "Must be a valid HTTPS URL",
      "response_timeout": "10 seconds",
      "retry_attempts": "3 times with exponential backoff",
      "expected_response": "HTTP 200-299 status code",
      "signature_header": "X-Webhook-Signature (HMAC-SHA256)"
    }
  },
  "timestamp": "1404-06-29 10:30:00"
}

curl -X POST "https://ipg.irandargah.com/v2/webhooks/unsubscribe" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"webhook_id": "65a4c7e8f1234"}'

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/webhooks/unsubscribe");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_TOKEN",
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['webhook_id' => '65a4c7e8f1234']));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const response = await fetch(
  "https://ipg.irandargah.com/v2/webhooks/unsubscribe",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ webhook_id: "65a4c7e8f1234" }),
  },
);

data := map[string]string{"webhook_id": "65a4c7e8f1234"}
jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", "https://ipg.irandargah.com/v2/webhooks/unsubscribe", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")
req.Header.Set("Content-Type", "application/json")

response = requests.post(
    'https://ipg.irandargah.com/v2/webhooks/unsubscribe',
    headers={
        'Authorization': 'Bearer YOUR_API_TOKEN',
        'Content-Type':  'application/json',
    },
    json={'webhook_id': '65a4c7e8f1234'}
)

var data = new { webhook_id = "65a4c7e8f1234" };

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var json    = JsonConvert.SerializeObject(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync("https://ipg.irandargah.com/v2/webhooks/unsubscribe", content);

{
  "success": true,
  "data": {
    "webhook_id": "65a4c7e8f1234",
    "status": "unsubscribed"
  },
  "message": "Webhook unsubscribed successfully",
  "timestamp": "1404-06-29 10:30:00"
}

curl -X POST "https://ipg.irandargah.com/v2/webhooks/test" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "webhook_id": "65a4c7e8f1234",
    "event_type": "payment.completed"
  }'

<?php
$data = [
    'webhook_id' => '65a4c7e8f1234',
    'event_type' => 'payment.completed',
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/webhooks/test");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_TOKEN",
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const response = await fetch("https://ipg.irandargah.com/v2/webhooks/test", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_TOKEN",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    webhook_id: "65a4c7e8f1234",
    event_type: "payment.completed",
  }),
});

data := map[string]string{
    "webhook_id": "65a4c7e8f1234",
    "event_type": "payment.completed",
}
jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", "https://ipg.irandargah.com/v2/webhooks/test", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")
req.Header.Set("Content-Type", "application/json")

response = requests.post(
    'https://ipg.irandargah.com/v2/webhooks/test',
    headers={
        'Authorization': 'Bearer YOUR_API_TOKEN',
        'Content-Type':  'application/json',
    },
    json={
        'webhook_id': '65a4c7e8f1234',
        'event_type': 'payment.completed',
    }
)

var data = new {
    webhook_id = "65a4c7e8f1234",
    event_type = "payment.completed",
};

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var json    = JsonConvert.SerializeObject(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync("https://ipg.irandargah.com/v2/webhooks/test", content);

{
  "success": true,
  "data": {
    "webhook_id": "65a4c7e8f1234",
    "event_type": "payment.completed",
    "test_result": {
      "status": "success",
      "response_code": 200,
      "response_time": null,
      "error": null
    }
  },
  "message": "Webhook test completed",
  "timestamp": "1404-06-29 10:30:00"
}

{
  "event": "payment.completed",
  "timestamp": "2025-10-01T10:35:00+03:30",
  "merchant_code": "MERCHANT001",
  "data": {
    "authority": "2025100121424146HC",
    "amount": 100000,
    "order_id": "ORDER-12345",
    "ref_code": "2025100121424146HC",
    "pan": "603799******1234",
    "verified_at": "1404-06-29 10:35:00"
  },
  "signature": "a1b2c3d4e5f6..."
}

<?php
function verifyWebhookSignature(string $rawBody, string $signature, string $secret): bool {
    // فقط فیلد data امضا می‌شود
    $payload  = json_decode($rawBody, true);
    $dataJson = json_encode($payload['data'], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);

    $expected = hash_hmac('sha256', $dataJson, $secret);
    return hash_equals($expected, $signature);
}

// استفاده
$body      = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';

if (! verifyWebhookSignature($body, $signature, 'YOUR_WEBHOOK_SECRET')) {
    http_response_code(401);
    exit('Invalid signature');
}
?>

const crypto = require("crypto");

function verifyWebhookSignature(rawBody, signature, secret) {
  // فقط فیلد data امضا می‌شود
  const payload = JSON.parse(rawBody);
  const dataJson = JSON.stringify(payload.data);

  const expected = crypto
    .createHmac("sha256", secret)
    .update(dataJson)
    .digest("hex");
  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

// در Express
app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
  const signature = req.headers["x-webhook-signature"];
  if (!verifyWebhookSignature(req.body, signature, "YOUR_WEBHOOK_SECRET")) {
    return res.status(401).send("Invalid signature");
  }
  // ... پردازش webhook
  res.sendStatus(200);
});

import hmac, hashlib, json

def verify_webhook_signature(raw_body: bytes, signature: str, secret: str) -> bool:
    # فقط فیلد data امضا می‌شود
    payload   = json.loads(raw_body)
    data_json = json.dumps(payload['data'], ensure_ascii=False, separators=(',', ':'))

    expected = hmac.new(secret.encode(), data_json.encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)

curl "https://ipg.irandargah.com/v2/reports/daily?date=1404-06-28" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

<?php
$date = '1404-06-28';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://ipg.irandargah.com/v2/reports/daily?date={$date}");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_TOKEN"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
?>

const date = "1404-06-28";

const response = await fetch(
  `https://ipg.irandargah.com/v2/reports/daily?date=${date}`,
  {
    headers: {
      Authorization: "Bearer YOUR_API_TOKEN",
    },
  }
);

date := "1404-06-28"
url := fmt.Sprintf("https://ipg.irandargah.com/v2/reports/daily?date=%s", date)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_TOKEN")

date = '1404-06-28'

response = requests.get(
    f'https://ipg.irandargah.com/v2/reports/daily?date={date}',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
)

string date = "1404-06-28";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN");

var response = await client.GetAsync($"https://ipg.irandargah.com/v2/reports/daily?date={date}");

{
  "success": true,
  "data": {
    "report_date": "1404-06-28",
    "summary": {
      "total_transactions": 150,
      "successful_transactions": 135,
      "failed_transactions": 15,
      "total_amount": 15000000,
      "successful_amount": 13500000,
      "success_rate": 90.0,
      "total_fees": 270000
    },
    "hourly_breakdown": [
      { "hour": 10, "transactions": 25, "amount": 2500000 }
    ],
    "payment_methods": [
      { "method": "card", "transactions": 140, "amount": 14000000 }
    ],
    "status_breakdown": [
      { "status": "completed", "count": 135 },
      { "status": "failed",    "count": 15  }
    ]
  },
  "timestamp": "1404-06-28 23:59:59"
}