# inquireTransactions

## Overview

The `inquireTransactions` command retrieves detailed information about transactions that have been processed through the Hyp platform. This command provides merchants with comprehensive transaction metadata beyond what's included in the initial transaction response, enabling better understanding, reconciliation, and reporting of payment activities.

When a transaction is performed, the response contains minimal information for performance reasons. The `inquireTransactions` command allows merchants to access the "fuller picture" of transactions when needed, including credit card types, digital wallet information, financial status, and transmission details.

## Use cases

* **Transaction status verification**: Check if transactions are authorized, transmitted, captured, or cancelled (see [Transaction Inquiry Overview](/enterprise/inquiring-transactions/overview.md))
* **Credit card type identification**: Determine the specific credit card provider and type used for a transaction
* **Digital wallet detection**: Identify if a transaction was processed through digital wallet services
* **Financial status tracking**: Monitor transaction states from authorization through settlement transmission
* **Reconciliation and reporting**: Gather detailed transaction data for accounting and business intelligence (see [Inquiry Examples](/enterprise/inquiring-transactions/examples.md))
* **Batch transaction analysis**: Query multiple transactions using date ranges or other criteria
* **Pagination support**: Handle large result sets with paging capabilities (see [Paging Documentation](/enterprise/inquiring-transactions/inquire-transactions-with-pagination.md))

## Request structure

For a comprehensive overview of the API request format and authentication, see [API Request & Response General Structure](/enterprise/introduction/request-and-response-general-structure.md).

Send a standard Hyp API request to your assigned server endpoint with the `inquireTransactions` command in the `int_in` parameter.

{% hint style="success" %}
**Server Endpoints**: Use the server endpoint provided during merchant onboarding (e.g., `https://your-hyp-environment-url/xpo/Relay`).
{% endhint %}

### XML payload structure

```xml
<ashrait>
    <request>
        <version>2000</version>
        <language>Eng</language>
        <dateTime/>
        <requestId/>
        <command>inquireTransactions</command>
        <inquireTransactions>
            <terminalNumber>{terminalNumber}</terminalNumber>
            <!-- Search criteria - at least one required -->
            <user>{userField}</user>
        </inquireTransactions>
    </request>
</ashrait>
```

## Required parameters

<details>

<summary><strong>terminalNumber</strong> - Your merchant terminal identifier</summary>

**Type**: String (Numeric, 10 digits)\
**Required**: Yes\
**Description**: The unique terminal number assigned during merchant onboarding

**Example**: `0882819014`

**Usage Notes**:

* Must match your assigned terminal number
* Used for transaction lookup and authorization
* Available in your merchant dashboard

</details>

<details>

<summary><strong>Search Criteria</strong> - Transaction identification (at least one required)</summary>

**Required**: At least one search criterion must be provided

**Available Search Criteria**:

**`tranId`** - Transaction ID

* **Type**: String (Numeric, 1-20 digits)
* **Description**: CG unique transaction identifier for specific transaction
* **Example**: `2546654`

**`cgUid`** - CG Identifier

* **Type**: String (Numeric, 1-20 digits)
* **Description**: Related identifier shared across transactions in the same financial operation
* **Example**: `2541154`

**`user`** - User Field

* **Type**: String (Alphanumeric, 1-19 characters, supports Hebrew)
* **Description**: Custom user identifier from the original transaction (recommended to be unique)
* **Example**: `customer123`

**`orgUid`** - Organization Identifier

* **Type**: String (Numeric, 1-20 digits)
* **Description**: Organization identifier for transaction lookup
* **Example**: `123456789`

</details>

## Optional parameters

<details>

<summary><strong>shiftId1</strong> - Shift identifier 1</summary>

**Type**: String (Numeric, 1-20 digits)\
**Required**: No\
**Description**: First shift identifier for transaction filtering

**Example**: `12345`

</details>

<details>

<summary><strong>shiftId2</strong> - Shift identifier 2</summary>

**Type**: String (Numeric, 1-20 digits)\
**Required**: No\
**Description**: Second shift identifier for transaction filtering

**Example**: `67890`

</details>

<details>

<summary><strong>shiftId3</strong> - Shift identifier 3</summary>

**Type**: String (Numeric, 1-20 digits)\
**Required**: No\
**Description**: Third shift identifier for transaction filtering

**Example**: `11111`

</details>

<details>

<summary><strong>shvaReferanceNo</strong> - Shva reference number</summary>

**Type**: String (Numeric, 7-8 digits)\
**Required**: No\
**Description**: Reference number for transmitted transaction batches

**Example**: `5568985`

**Usage Notes**:

* Since shvaReferanceNo may return a large number of records, [paging](/enterprise/inquiring-transactions/inquire-transactions-with-pagination.md) must be implemented

</details>

<details>

<summary><strong>transmitId</strong> - Transmission identifier</summary>

**Type**: String (Numeric, 1-20 digits)\
**Required**: No\
**Description**: Identifier for a specific transmission batch

**Example**: `123456789`

**Usage Notes**:

* Since transmitId may return a large number of records, [paging](/enterprise/inquiring-transactions/inquire-transactions-with-pagination.md) must be implemented

</details>

<details>

<summary><strong>financialStatus</strong> - Transaction financial status</summary>

**Type**: String (Enum)\
**Required**: No\
**Description**: Filter by transaction financial state

**Valid Values**: `AUTHORIZED`, `REJECTED`, `CAPTURED`, `TRANSMITTED`, `PENDING`, `CANCELLED`\
**Example**: `TRANSMITTED`

**Usage Notes**:

* The financialStatus parameter should only be used as an additional search parameter (for example, in combination with a search by tranId), and not as a standalone parameter
* `PENDING` applies for J9 transactions
* `CANCELLED` applies for cancelled J5 transactions

</details>

### Date range parameters

<details>

<summary><strong>fromDealDate / toDealDate</strong> - Deal date range</summary>

**Type**: String (Date, YYYY-MM-DD format)\
**Required**: No\
**Description**: Date range filter for transactions by deal date

**Example**: `2025-01-21`

**Usage Notes**:

* Use both parameters together to define a date range
* Filters transactions by the date they were processed

</details>

<details>

<summary><strong>fromTransmitDate / toTransmitDate</strong> - Transmission date range</summary>

**Type**: String (Date, YYYY-MM-DD format)\
**Required**: No\
**Description**: Date range filter for transactions by transmission date

**Example**: `2025-01-21`

**Usage Notes**:

* Use both parameters together to define a date range
* Filters transactions by the date they were transmitted to Shva

</details>

<details>

<summary><strong>fromShiftTxnDate / toShiftTxnDate</strong> - Shift transaction date range</summary>

**Type**: String (Date, YYYY-MM-DD format)\
**Required**: No\
**Description**: Date range filter for transactions by shift transaction date

**Example**: `2025-01-21`

**Usage Notes**:

* Use both parameters together to define a date range
* Filters transactions by a shift-specific date field

</details>

## Response structure

### Successful response

A successful `inquireTransactions` response contains transaction details and summary information:

```xml
<?xml version='1.0'?>
<ashrait>
    <response>
        <command>inquireTransactions</command>
        <dateTime>2025-07-24 16:18</dateTime>
        <requestId>723232323</requestId>
        <tranId>677461</tranId>
        <result>000</result>
        <message>Transaction inquiry successful</message>
        <userMessage>Transaction inquiry successful</userMessage>
        <version>2000</version>
        <language>Eng</language>
        <inquireTransactions>
            <transactions>
                <transaction>
                    <tranId>254151</tranId>
                    <total>255</total>
                    <transactionDate>2025-07-24 09:55:38</transactionDate>
                    <financialStatus>TRANSMITTED</financialStatus>
                    <creditCompany code="2">Visa</creditCompany>
                    <cardAcquirer code="6">Alphacard</cardAcquirer>
                    <transactionType code="01">RegularDebit</transactionType>
                    <terminalNumber>0880700014</terminalNumber>
                    <cardId>1044318853344580</cardId>
                    <status>000</status>
                    <shovar>01001001</shovar>
                    <shvaReferanceNo>5574444</shvaReferanceNo>
                    <!-- Additional transaction fields -->
                </transaction>
                <!-- Additional transactions if found -->
            </transactions>
            <totals>
                <total>1</total>
                <totalMatch>1</totalMatch>
            </totals>
        </inquireTransactions>
    </response>
</ashrait>
```

**Key Response Fields**:

* `result`: `000` indicates successful inquiry
* `transactions`: Container for all found transactions
* `transaction`: Individual transaction details
* `totals/total`: Number of transactions in current response
* `totals/totalMatch`: Total number of transactions matching criteria

### Error response

Error responses include specific error codes and messages:

```xml
<?xml version='1.0'?>
<ashrait>
    <response>
        <command>inquireTransactions</command>
        <result>099</result>
        <message>No transactions found matching criteria</message>
        <userMessage>No matching transactions found</userMessage>
    </response>
</ashrait>
```

## Code examples

{% tabs %}
{% tab title="cURL" %}

```bash
#!/bin/bash

# Transaction inquiry by user field
curl -X POST https://your-hyp-environment-url/xpo/Relay \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "user=your_username" \
  -d "password=your_password" \
  -d "int_in=$(cat <<'EOF'
<ashrait>
    <request>
        <version>2000</version>
        <language>Eng</language>
        <dateTime/>
        <requestId/>
        <command>inquireTransactions</command>
        <inquireTransactions>
            <terminalNumber>0882819014</terminalNumber>
            <user>customer123</user>
        </inquireTransactions>
    </request>
</ashrait>
EOF
)"

# Transaction inquiry by date range
curl -X POST https://your-hyp-environment-url/xpo/Relay \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "user=your_username" \
  -d "password=your_password" \
  -d "int_in=$(cat <<'EOF'
<ashrait>
    <request>
        <version>2000</version>
        <language>Eng</language>
        <dateTime/>
        <requestId/>
        <command>inquireTransactions</command>
        <inquireTransactions>
            <terminalNumber>0882819014</terminalNumber>
            <fromDealDate>2025-07-20</fromDealDate>
            <toDealDate>2025-07-24</toDealDate>
            <financialStatus>TRANSMITTED</financialStatus>
        </inquireTransactions>
    </request>
</ashrait>
EOF
)"
```

{% endtab %}

{% tab title="Java" %}

```java
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class InquireTransactionsExample {
    
    public static class InquiryResult {
        public boolean success;
        public List<Transaction> transactions;
        public int totalMatch;
        public String error;
        
        public static class Transaction {
            public String tranId;
            public String total;
            public String transactionDate;
            public String financialStatus;
            public String creditCompany;
        }
    }
    
    public static InquiryResult inquireTransactions(String terminalNumber, String userField, String fromDate, String toDate) throws IOException {
        String serverUrl = "https://your-hyp-environment-url/xpo/Relay";
        String username = "your_username";
        String password = "your_password";
        
        InquiryResult result = new InquiryResult();
        result.transactions = new ArrayList<>();
        
        // Build XML payload
        StringBuilder xmlPayload = new StringBuilder();
        xmlPayload.append("<ashrait>")
                  .append("<request>")
                  .append("<version>2000</version>")
                  .append("<language>Eng</language>")
                  .append("<dateTime/>")
                  .append("<requestId/>")
                  .append("<command>inquireTransactions</command>")
                  .append("<inquireTransactions>")
                  .append("<terminalNumber>").append(terminalNumber).append("</terminalNumber>");
        
        if (userField != null && !userField.isEmpty()) {
            xmlPayload.append("<user>").append(userField).append("</user>");
        }
        
        if (fromDate != null && toDate != null) {
            xmlPayload.append("<fromDealDate>").append(fromDate).append("</fromDealDate>")
                      .append("<toDealDate>").append(toDate).append("</toDealDate>");
        }
        
        xmlPayload.append("</inquireTransactions>")
                  .append("</request>")
                  .append("</ashrait>");
        
        // Build POST data
        String postData = "user=" + URLEncoder.encode(username, StandardCharsets.UTF_8) +
                         "&password=" + URLEncoder.encode(password, StandardCharsets.UTF_8) +
                         "&int_in=" + URLEncoder.encode(xmlPayload.toString(), StandardCharsets.UTF_8);
        
        // Send request
        URL url = new URL(serverUrl);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        connection.setDoOutput(true);
        
        try (OutputStream os = connection.getOutputStream()) {
            os.write(postData.getBytes(StandardCharsets.UTF_8));
        }
        
        // Read response
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(connection.getInputStream()))) {
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            
            // Parse response (simplified - use proper XML parser in production)
            String responseText = response.toString();
            if (responseText.contains("<result>000</result>")) {
                result.success = true;
                result.totalMatch = Integer.parseInt(extractValue(responseText, "totalMatch"));
                
                // Extract transaction details (simplified parsing)
                InquiryResult.Transaction transaction = new InquiryResult.Transaction();
                transaction.tranId = extractValue(responseText, "tranId");
                transaction.total = extractValue(responseText, "total");
                transaction.transactionDate = extractValue(responseText, "transactionDate");
                transaction.financialStatus = extractValue(responseText, "financialStatus");
                transaction.creditCompany = extractValue(responseText, "creditCompany");
                result.transactions.add(transaction);
            } else {
                result.success = false;
                result.error = extractValue(responseText, "userMessage");
            }
        }
        
        return result;
    }
    
    private static String extractValue(String xml, String tagName) {
        String startTag = "<" + tagName + ">";
        String endTag = "</" + tagName + ">";
        int start = xml.indexOf(startTag);
        if (start != -1) {
            start += startTag.length();
            int end = xml.indexOf(endTag, start);
            if (end != -1) {
                return xml.substring(start, end);
            }
        }
        return "";
    }
    
    public static void main(String[] args) throws IOException {
        // Inquiry by user field
        InquiryResult result = inquireTransactions("0882819014", "customer123", null, null);
        
        if (result.success) {
            System.out.println("Transaction inquiry successful!");
            System.out.println("Total matches: " + result.totalMatch);
            for (InquiryResult.Transaction tx : result.transactions) {
                System.out.println("Transaction ID: " + tx.tranId);
                System.out.println("Amount: " + tx.total);
                System.out.println("Status: " + tx.financialStatus);
            }
        } else {
            System.out.println("Transaction inquiry failed: " + result.error);
        }
    }
}
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
from urllib.parse import urlencode
from xml.etree import ElementTree as ET
from typing import List, Dict, Optional

def inquire_transactions(terminal_number: str, user_field: str = None, 
                        from_date: str = None, to_date: str = None,
                        financial_status: str = None) -> Dict:
    """Inquire transactions using various search criteria"""
    
    server_url = "https://your-hyp-environment-url/xpo/Relay"
    username = "your_username"
    password = "your_password"
    
    # Build XML payload
    xml_payload = f"""
    <ashrait>
        <request>
            <version>2000</version>
            <language>Eng</language>
            <dateTime/>
            <requestId/>
            <command>inquireTransactions</command>
            <inquireTransactions>
                <terminalNumber>{terminal_number}</terminalNumber>
                {f'<user>{user_field}</user>' if user_field else ''}
                {f'<fromDealDate>{from_date}</fromDealDate>' if from_date else ''}
                {f'<toDealDate>{to_date}</toDealDate>' if to_date else ''}
                {f'<financialStatus>{financial_status}</financialStatus>' if financial_status else ''}
            </inquireTransactions>
        </request>
    </ashrait>
    """
    
    # Prepare POST data
    post_data = {
        'user': username,
        'password': password,
        'int_in': xml_payload.strip()
    }
    
    try:
        # Send request
        response = requests.post(
            server_url,
            data=post_data,
            headers={'Content-Type': 'application/x-www-form-urlencoded'},
            timeout=30
        )
        
        response.raise_for_status()
        
        # Parse XML response
        root = ET.fromstring(response.text)
        result_code = root.find('.//result').text
        
        if result_code == '000':
            transactions = []
            
            # Extract transaction details
            for transaction_elem in root.findall('.//transaction'):
                transaction = {
                    'tran_id': transaction_elem.find('tranId').text if transaction_elem.find('tranId') is not None else '',
                    'total': transaction_elem.find('total').text if transaction_elem.find('total') is not None else '',
                    'transaction_date': transaction_elem.find('transactionDate').text if transaction_elem.find('transactionDate') is not None else '',
                    'financial_status': transaction_elem.find('financialStatus').text if transaction_elem.find('financialStatus') is not None else '',
                    'credit_company': transaction_elem.find('creditCompany').text if transaction_elem.find('creditCompany') is not None else '',
                    'card_acquirer': transaction_elem.find('cardAcquirer').text if transaction_elem.find('cardAcquirer') is not None else '',
                    'transaction_type': transaction_elem.find('transactionType').text if transaction_elem.find('transactionType') is not None else ''
                }
                transactions.append(transaction)
            
            total_match = root.find('.//totalMatch').text if root.find('.//totalMatch') is not None else '0'
            
            return {
                'success': True,
                'transactions': transactions,
                'total_match': int(total_match),
                'message': root.find('.//userMessage').text
            }
        else:
            return {
                'success': False,
                'error_code': result_code,
                'error': root.find('.//userMessage').text
            }
            
    except requests.exceptions.RequestException as e:
        return {
            'success': False,
            'error': f"Request failed: {e}"
        }
    except ET.ParseError as e:
        return {
            'success': False,
            'error': f"XML parsing failed: {e}"
        }

# Example usage
if __name__ == "__main__":
    # Inquiry by user field
    result = inquire_transactions("0882819014", user_field="customer123")
    
    if result['success']:
        print("Transaction inquiry successful!")
        print(f"Total matches: {result['total_match']}")
        
        for transaction in result['transactions']:
            print(f"Transaction ID: {transaction['tran_id']}")
            print(f"Amount: {transaction['total']}")
            print(f"Status: {transaction['financial_status']}")
            print(f"Credit Company: {transaction['credit_company']}")
            print("---")
    else:
        print(f"Transaction inquiry failed: {result['error']}")
    
    # Inquiry by date range and status
    date_result = inquire_transactions(
        "0882819014", 
        from_date="2025-07-20", 
        to_date="2025-07-24",
        financial_status="TRANSMITTED"
    )
    
    if date_result['success']:
        print(f"Date range inquiry found {date_result['total_match']} transactions")
    else:
        print(f"Date range inquiry failed: {date_result['error']}")
```

{% endtab %}

{% tab title="Node.js" %}

```javascript
const https = require('https');
const querystring = require('querystring');
const { parseStringPromise } = require('xml2js');

function inquireTransactions(terminalNumber, options = {}) {
    return new Promise((resolve, reject) => {
        const serverUrl = 'https://your-hyp-environment-url/xpo/Relay';
        const username = 'your_username';
        const password = 'your_password';
        
        // Build XML payload
        let xmlPayload = `
        <ashrait>
            <request>
                <version>2000</version>
                <language>Eng</language>
                <dateTime/>
                <requestId/>
                <command>inquireTransactions</command>
                <inquireTransactions>
                    <terminalNumber>${terminalNumber}</terminalNumber>`;
        
        if (options.userField) {
            xmlPayload += `<user>${options.userField}</user>`;
        }
        
        if (options.fromDate && options.toDate) {
            xmlPayload += `<fromDealDate>${options.fromDate}</fromDealDate>`;
            xmlPayload += `<toDealDate>${options.toDate}</toDealDate>`;
        }
        
        if (options.financialStatus) {
            xmlPayload += `<financialStatus>${options.financialStatus}</financialStatus>`;
        }
        
        if (options.cardBrand) {
            xmlPayload += `<cardBrand>${options.cardBrand}</cardBrand>`;
        }
        
        xmlPayload += `
                </inquireTransactions>
            </request>
        </ashrait>
        `;
        
        // Prepare POST data
        const postData = querystring.stringify({
            user: username,
            password: password,
            int_in: xmlPayload.trim()
        });
        
        const requestOptions = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': Buffer.byteLength(postData)
            }
        };
        
        const req = https.request(serverUrl, requestOptions, async (res) => {
            let responseData = '';
            
            res.on('data', (chunk) => {
                responseData += chunk;
            });
            
            res.on('end', async () => {
                try {
                    if (res.statusCode === 200) {
                        // Parse XML response
                        const result = await parseStringPromise(responseData);
                        const response = result.ashrait.response[0];
                        const resultCode = response.result[0];
                        
                        if (resultCode === '000') {
                            const inquiryData = response.inquireTransactions[0];
                            const transactions = [];
                            
                            // Extract transactions if present
                            if (inquiryData.transactions && inquiryData.transactions[0].transaction) {
                                for (const txElement of inquiryData.transactions[0].transaction) {
                                    const transaction = {
                                        tranId: txElement.tranId ? txElement.tranId[0] : '',
                                        total: txElement.total ? txElement.total[0] : '',
                                        transactionDate: txElement.transactionDate ? txElement.transactionDate[0] : '',
                                        financialStatus: txElement.financialStatus ? txElement.financialStatus[0] : '',
                                        creditCompany: txElement.creditCompany ? txElement.creditCompany[0]['_'] || txElement.creditCompany[0] : '',
                                        cardAcquirer: txElement.cardAcquirer ? txElement.cardAcquirer[0]['_'] || txElement.cardAcquirer[0] : '',
                                        transactionType: txElement.transactionType ? txElement.transactionType[0]['_'] || txElement.transactionType[0] : ''
                                    };
                                    transactions.push(transaction);
                                }
                            }
                            
                            const totalMatch = inquiryData.totals && inquiryData.totals[0].totalMatch 
                                ? parseInt(inquiryData.totals[0].totalMatch[0]) : 0;
                            
                            resolve({
                                success: true,
                                transactions: transactions,
                                totalMatch: totalMatch,
                                message: response.userMessage[0]
                            });
                        } else {
                            resolve({
                                success: false,
                                errorCode: resultCode,
                                error: response.userMessage[0]
                            });
                        }
                    } else {
                        reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
                    }
                } catch (parseError) {
                    reject(new Error(`XML parsing failed: ${parseError.message}`));
                }
            });
        });
        
        req.on('error', (error) => {
            reject(error);
        });
        
        req.write(postData);
        req.end();
    });
}

// Example usage
async function example() {
    try {
        // Inquiry by user field
        const result = await inquireTransactions('0882819014', {
            userField: 'customer123'
        });
        
        if (result.success) {
            console.log('Transaction inquiry successful!');
            console.log(`Total matches: ${result.totalMatch}`);
            
            result.transactions.forEach((transaction, index) => {
                console.log(`Transaction ${index + 1}:`);
                console.log(`  ID: ${transaction.tranId}`);
                console.log(`  Amount: ${transaction.total}`);
                console.log(`  Status: ${transaction.financialStatus}`);
                console.log(`  Credit Company: ${transaction.creditCompany}`);
                console.log('---');
            });
        } else {
            console.log(`Transaction inquiry failed: ${result.error}`);
        }
        
        // Inquiry by date range and card brand
        const dateResult = await inquireTransactions('0882819014', {
            fromDate: '2025-07-20',
            toDate: '2025-07-24',
            financialStatus: 'TRANSMITTED',
            cardBrand: 'Visa'
        });
        
        if (dateResult.success) {
            console.log(`Date range inquiry found ${dateResult.totalMatch} Visa transactions`);
        } else {
            console.log(`Date range inquiry failed: ${dateResult.error}`);
        }
        
    } catch (error) {
        console.error('Operation failed:', error.message);
    }
}

example();
```

{% endtab %}
{% endtabs %}

## Error codes

| Error Code | Description                                                | Resolution                                                     |
| ---------- | ---------------------------------------------------------- | -------------------------------------------------------------- |
| **000**    | Success                                                    | Transaction inquiry completed successfully                     |
| **325**    | Invalid XML format                                         | Check XML structure and ensure all required fields are present |
| **405**    | SSL HTTPS customers are not permitted to access the system | Verify username and password are correct                       |
| **414**    | An XML field or an INT\_IN parameter is too short/long     | Check field lengths match API requirements                     |

{% hint style="warning" %}
**Performance Note**: Transaction inquiry should not be performed continuously. Use it when specific transaction details are needed for business purposes, reconciliation, or troubleshooting.
{% endhint %}

## Related commands

* [**`doDeal`**](/enterprise/api-reference/dodeal.md) - Process original transactions that can later be inquired
* [**`refundDeal`**](/enterprise/api-reference/refunddeal.md) - Refund transactions (check status before refunding)
* [**`cancelDeal`**](/enterprise/api-reference/canceldeal.md) - Cancel transactions (verify transmission status)
* [**`transmitInquire`**](/enterprise/api-reference/transmitinquire.md) - Query transmission status and batch information
* [**Request Structure**](/enterprise/introduction/request-and-response-general-structure.md) - General API request format
* [**Transaction Inquiry Overview**](/enterprise/inquiring-transactions/overview.md) - Detailed guide on when and how to use transaction inquiries
* [**Inquiry Examples**](/enterprise/inquiring-transactions/examples.md) - Practical examples and use cases
* [**Paging Support**](/enterprise/inquiring-transactions/inquire-transactions-with-pagination.md) - Handle large result sets with pagination


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://developers.hyp.co.il/enterprise/api-reference/inquiretransactions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.