Check Status

GET

Check the status of a disbursement transaction.

Endpoint

GET /api/v1/check-status/{transaction_id}

Request Headers

Header Required Description
Authorization Yes Bearer token from login
Accept Yes application/json

Path Parameters

Parameter Type Required Description
transaction_id string Yes Transaction ID or Reference ID

Alternative Endpoint (Query Parameter)

GET /api/v1/check-status?reference_id={reference_id}

Query Parameters

Parameter Type Required Description
reference_id string Yes Your unique reference ID

Response

Success Response

{
    "success": true,
    "message": "Transaction status retrieved successfully",
    "data": {
        "transaction_id": "TRN_67890123456",
        "reference_id": "TRN20240115001",
        "status": "SUCCESS",
        "amount": 100000,
        "fee": 2500,
        "total_amount": 102500,
        "bank_code": "5",
        "bank_name": "Bank Central Asia",
        "account_number": "1234567890",
        "account_name": "John Doe",
        "description": "Salary payment",
        "created_at": "2024-01-15T10:30:00Z",
        "processed_at": "2024-01-15T10:32:15Z",
        "failure_reason": null
    },
    "meta": {
        "timestamp": "2024-01-15T10:35:00Z"
    }
}

Response Fields

Field Type Description
transaction_id string System generated transaction ID
reference_id string Your unique reference ID
status string Transaction status (PROCESS, SUCCESS, FAILED)
amount decimal Disbursement amount
fee decimal Transaction fee
total_amount decimal Total amount (amount + fee)
bank_code string Recipient bank code
account_number string Recipient account number
account_name string Recipient account name
description string Transaction description
created_at string Transaction creation timestamp
processed_at string Transaction processing timestamp
failure_reason string Reason for failure (if status is FAILED)

Transaction Status Types

Status Description
PROCESS Transaction is being processed
SUCCESS Transaction completed successfully
FAILED Transaction failed

Code Examples

PHP Example (Using Transaction ID)

<?php

$transactionId = "TRN_67890123456";

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://openapi.swiftrans.id:7654/api/v1/check-status/' . $transactionId,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer ' . $accessToken,
        'Accept: application/json'
    ),
));

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

$result = json_decode($response, true);

if ($httpCode === 200 && $result['success']) {
    $status = $result['data']['status'];
    echo "Transaction status: " . $status;

    if ($status === 'SUCCESS') {
        echo "Transaction completed successfully";
    } elseif ($status === 'FAILED') {
        echo "Transaction failed: " . $result['data']['failure_reason'];
    } else {
        echo "Transaction is still process";
    }
} else {
    echo "Failed to get status: " . $result['message'];
}

PHP Example (Using Reference ID)

<?php

$referenceId = "TRN20240115001";

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://openapi.swiftrans.id:7654/api/v1/check-status?reference_id=' . $referenceId,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer ' . $accessToken,
        'Accept: application/json'
    ),
));

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

$result = json_decode($response, true);

JavaScript Example

// Using transaction ID
async function checkStatusByTransactionId(transactionId) {
    try {
        const response = await fetch(`https://openapi.swiftrans.id:7654/api/v1/check-status/${transactionId}`, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${accessToken}`,
                'Accept': 'application/json'
            }
        });

        const result = await response.json();

        if (response.ok && result.success) {
            const status = result.data.status;
            console.log(`Transaction status: ${status}`);

            switch (status) {
                case 'SUCCESS':
                    console.log('Transaction completed successfully');
                    break;
                case 'FAILED':
                    console.log(`Transaction failed: ${result.data.failure_reason}`);
                    break;
                case 'PROCESS':
                    console.log('Transaction is still process');
                    break;
            }

            return result.data;
        } else {
            console.error('Failed to get status:', result.message);
            return null;
        }
    } catch (error) {
        console.error('Status check error:', error);
        return null;
    }
}

// Using reference ID
async function checkStatusByReferenceId(referenceId) {
    try {
        const response = await fetch(`https://openapi.swiftrans.id:7654/api/v1/check-status?reference_id=${referenceId}`, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${accessToken}`,
                'Accept': 'application/json'
            }
        });

        const result = await response.json();
        return result;
    } catch (error) {
        console.error('Status check error:', error);
        return null;
    }
}

cURL Examples

# Using transaction ID
curl -X GET https://openapi.swiftrans.id:7654/api/v1/check-status/TRN_67890123456 \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Accept: application/json"

# Using reference ID
curl -X GET "https://openapi.swiftrans.id:7654/api/v1/check-status?reference_id=TRN20240115001" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Accept: application/json"

Error Responses

Transaction Not Found

{
    "success": false,
    "message": "Transaction not found",
    "error_code": "TRANSACTION_NOT_FOUND"
}

Invalid Transaction ID

{
    "success": false,
    "message": "Invalid transaction ID format",
    "error_code": "INVALID_TRANSACTION_ID"
}

Unauthorized

{
    "success": false,
    "message": "Invalid or expired token",
    "error_code": "UNAUTHORIZED"
}

Status Polling Implementation

PHP Polling Example

<?php

function pollTransactionStatus($accessToken, $transactionId, $maxAttempts = 30, $intervalSeconds = 10) {
    for ($attempt = 1; $attempt <= $maxAttempts; $attempt++) {
        echo "Checking status (attempt $attempt)...\n";

        $status = checkTransactionStatus($accessToken, $transactionId);

        if ($status && $status['status'] !== 'PROCESS') {
            echo "Final status: " . $status['status'] . "\n";
            return $status;
        }

        if ($attempt < $maxAttempts) {
            echo "Status still process, waiting {$intervalSeconds} seconds...\n";
            sleep($intervalSeconds);
        }
    }

    echo "Timeout: Transaction still process after maximum attempts\n";
    return null;
}

function checkTransactionStatus($accessToken, $transactionId) {
    $curl = curl_init();

    curl_setopt_array($curl, array(
        CURLOPT_URL => 'https://openapi.swiftrans.id:7654/api/v1/check-status/' . $transactionId,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST => 'GET',
        CURLOPT_HTTPHEADER => array(
            'Authorization: Bearer ' . $accessToken,
            'Accept: application/json'
        ),
    ));

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

    if ($httpCode === 200) {
        $result = json_decode($response, true);
        return $result['success'] ? $result['data'] : null;
    }

    return null;
}

// Usage
$finalStatus = pollTransactionStatus($accessToken, "TRN_67890123456");

JavaScript Polling Example

class TransactionStatusPoller {
    constructor(accessToken) {
        this.accessToken = accessToken;
    }

    async pollStatus(transactionId, maxAttempts = 30, intervalMs = 10000) {
        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
            console.log(`Checking status (attempt ${attempt})...`);

            const status = await this.checkStatus(transactionId);

            if (status && status.status !== 'PROCESS') {
                console.log(`Final status: ${status.status}`);
                return status;
            }

            if (attempt < maxAttempts) {
                console.log(`Status still process, waiting ${intervalMs/1000} seconds...`);
                await this.delay(intervalMs);
            }
        }

        console.log('Timeout: Transaction still process after maximum attempts');
        return null;
    }

    async checkStatus(transactionId) {
        try {
            const response = await fetch(`https://openapi.swiftrans.id:7654/api/v1/check-status/${transactionId}`, {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${this.accessToken}`,
                    'Accept': 'application/json'
                }
            });

            const result = await response.json();
            return result.success ? result.data : null;
        } catch (error) {
            console.error('Status check error:', error);
            return null;
        }
    }

    delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}

// Usage
const poller = new TransactionStatusPoller(accessToken);
const finalStatus = await poller.pollStatus("TRN_67890123456");

Best Practices

  1. Polling Strategy: Implement exponential backoff for status polling
  2. Timeout Handling: Set reasonable timeout limits for status checks
  3. Error Handling: Handle network errors and API failures gracefully
  4. Callback Alternative: Use callback URLs instead of polling when possible
  5. Caching: Cache status results to avoid unnecessary API calls

Rate Limiting

  • Maximum 120 status check requests per minute
  • Implement exponential backoff for rate limit errors
  • Use callback URLs to reduce polling frequency

Important Notes

  • Status updates are real-time
  • PROCESS status may last up to 30 minutes for some banks
  • FAILED transactions include failure reasons
  • Use callback URLs for better performance than polling