Skip to content

Monitoring Transaction Status⚓︎

BEGINNER

After announcing a transaction to the Symbol network, it remains unconfirmed until it is included in a block.

Monitoring status changes is essential for building responsive applications that can react to transaction confirmation or failure.

This tutorial shows how to monitor a transaction's status as it moves from unconfirmed to confirmed.

Polling is not recommended for production

This tutorial uses polling to check the transaction status. Polling is used here for illustration purposes, but it is not the recommended approach for production applications.

WebSockets provide a more responsive solution without the overhead of repeated API calls.

Prerequisites⚓︎

This tutorial uses the Symbol REST API without requiring an SDK. You only need a way to make HTTP requests.

Full Code⚓︎

The following is the complete code listing for this tutorial. A detailed, step-by-step explanation follows in the next section.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
import json
import os
import time
import urllib.request

# Configuration
NODE_URL = os.getenv("NODE_URL", "https://reference.symboltest.net:3001")
print(f'Using node {NODE_URL}')

# Transaction hash to monitor
transaction_hash = os.getenv("TRANSACTION_HASH",
    "2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA")

print(f"Monitoring transaction: {transaction_hash}")


def wait_for_transaction_confirmation(
    tx_hash, max_attempts=60, wait_seconds=2
):
    """
    Poll the transaction status endpoint until the transaction
    is confirmed.

    Args:
        tx_hash: The hash of the transaction to monitor
        max_attempts: Maximum number of polling attempts for confirmation
        wait_seconds: Seconds to wait between attempts

    Returns:
        True if transaction was confirmed
    """
    status_path = f"/transactionStatus/{tx_hash}"
    print("\nWaiting for transaction confirmation")
    print(f"Polling {status_path}")

    for attempt in range(1, max_attempts + 1):
        try:
            # Query the transaction status endpoint
            url = f"{NODE_URL}{status_path}"
            with urllib.request.urlopen(url) as response:
                response_json = json.loads(response.read().decode())

                # Parse the response
                status_group = response_json["group"]
                status_code = response_json["code"]
                status_hash = response_json["hash"]
                status_deadline = response_json["deadline"]

                print(f"  Attempt {attempt}:")
                print(f"    Status: {status_group}")
                print(f"    Code: {status_code}")
                print(f"    Hash: {status_hash}")
                print(f"    Deadline: {status_deadline}")

                # Check if the transaction has been confirmed
                if status_group == "confirmed":
                    print("\nTransaction confirmed!")
                    return True

                # Check if the transaction failed
                if status_group == "failed":
                    print(
                        f"\nTransaction failed with code: {status_code}"
                    )
                    raise RuntimeError(
                        f"Transaction failed: {status_code}"
                    )

        except urllib.error.HTTPError as err:
            if err.status == 404:
                print(
                    f"  Attempt {attempt}: Transaction status not "
                    "yet available"
                )
            else:
                raise

        # Wait before next attempt (except on last attempt)
        if attempt < max_attempts:
            time.sleep(wait_seconds)

    print(f"\nTransaction not confirmed after {max_attempts} attempts")
    raise RuntimeError(
        f"Transaction {transaction_hash} not confirmed in time"
    )


# Monitor the transaction until it's confirmed
wait_for_transaction_confirmation(transaction_hash)

Download source

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
// Configuration
const NODE_URL = process.env.NODE_URL ||
    'https://reference.symboltest.net:3001';
console.log('Using node', NODE_URL);

// Transaction hash to monitor.
const transactionHash = process.env.TRANSACTION_HASH ||
    '2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA';

console.log(`Monitoring transaction: ${transactionHash}`);

/**
 * Poll the transaction status endpoint until it is confirmed.
 * @param {string} txHash - The hash of the transaction to monitor
 * @param {number} maxAttempts - Maximum number of polling attempts
 *   for confirmation
 * @param {number} waitSeconds - Seconds to wait between attempts
 * @returns {boolean} True if transaction was confirmed
 */
async function waitForTransactionConfirmation(
    txHash,
    maxAttempts = 60,
    waitSeconds = 2
) {
    const statusPath = `/transactionStatus/${txHash}`;
    console.log('\nWaiting for transaction confirmation');
    console.log(`Polling ${statusPath}`);

    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
            // Query the transaction status endpoint
            const statusResponse =
                await fetch(`${NODE_URL}${statusPath}`);

            if (!statusResponse.ok) {
                const status = statusResponse.status;
                const statusText = statusResponse.statusText;
                const error = new Error(`HTTP ${status}: ${statusText}`);
                error.status = statusResponse.status;
                throw error;
            }

            const statusJSON = await statusResponse.json();

            // Parse the response
            const statusGroup = statusJSON.group;
            const statusCode = statusJSON.code;
            const statusHash = statusJSON.hash;
            const statusDeadline = statusJSON.deadline;

            console.log(`  Attempt ${attempt}:`);
            console.log(`    Status: ${statusGroup}`);
            console.log(`    Code: ${statusCode}`);
            console.log(`    Hash: ${statusHash}`);
            console.log(`    Deadline: ${statusDeadline}`);

            // Check if the transaction has been confirmed
            if ('confirmed' === statusGroup) {
                console.log('\nTransaction confirmed!');
                return true;
            }

            // Check if the transaction failed
            if ('failed' === statusGroup) {
                console.log(
                    `\nTransaction failed with code: ${statusCode}`
                );
                throw new Error(`Transaction failed: ${statusCode}`);
            }

        } catch (error) {
            if (404 === error.status) {
                console.log(
                    `  Attempt ${attempt}: Transaction status not yet ` +
                    'available'
                );
            } else {
                throw error;
            }
        }

        // Wait before next attempt (except on last attempt)
        if (attempt < maxAttempts) {
            await new Promise(resolve => {
                setTimeout(resolve, waitSeconds * 1000);
            });
        }
    }

    console.log(
        `\nTransaction not confirmed after ${maxAttempts} attempts`
    );
    throw new Error(
        `Transaction ${txHash} not confirmed in time`
    );
}

// Monitor the transaction until it's confirmed
await waitForTransactionConfirmation(transactionHash);

Download source

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
//JAVA 21+
//DEPS org.symbol:symbol-sdk:3.3.1

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

// Configuration
public final class MonitoringStatus {
    private static final ObjectMapper JSON_MAPPER = new ObjectMapper();

    private static final HttpClient HTTP_CLIENT =
        HttpClient.newHttpClient();

    private static final String NODE_URL = System.getenv().getOrDefault(
        "NODE_URL", "https://reference.symboltest.net:3001");

    public static void main(final String[] args) {
        try {
            new MonitoringStatus().run();
        } catch (final Exception ex) {
            System.out.println(null == ex.getMessage()
                ? ex.toString()
                : ex.getMessage());
        }
    }

    private void run() throws IOException, InterruptedException {
        System.out.printf("Using node %s%n", NODE_URL);

        // Transaction hash to monitor.
        final String transactionHash =
            System.getenv().getOrDefault("TRANSACTION_HASH",
            "2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF95236534"
                + "06E04C7EA");

        System.out.printf("Monitoring transaction: %s%n", transactionHash);

        // Monitor the transaction until it's confirmed
        waitForTransactionConfirmation(transactionHash, 60, 2);
    }


    /**
     * Poll the transaction status endpoint until it is confirmed.
     * @param txHash The hash of the transaction to monitor
     * @param maxAttempts Maximum number of polling attempts
     *   for confirmation
     * @param waitSeconds Seconds to wait between attempts
     * @return True if transaction was confirmed
     */
    private boolean waitForTransactionConfirmation(
        final String txHash,
        final int maxAttempts,
        final int waitSeconds
    ) throws IOException, InterruptedException {
        final String statusPath = "/transactionStatus/" + txHash;
        System.out.println("\nWaiting for transaction confirmation");
        System.out.printf("Polling %s%n", statusPath);

        for (int attempt = 1; attempt <= maxAttempts; ++attempt) {
            // Query the transaction status endpoint
            final HttpRequest statusRequest = HttpRequest.newBuilder(
                URI.create(NODE_URL + statusPath)).GET().build();
            final HttpResponse<String> statusResponse = HTTP_CLIENT.send(
                statusRequest, BodyHandlers.ofString());

            if (404 == statusResponse.statusCode()) {
                System.out.printf(
                    "  Attempt %d: Transaction status not yet available%n",
                    attempt);
            }
            else {
                if (statusResponse.statusCode() / 100 != 2)
                    throw new IOException(
                        "HTTP " + statusResponse.statusCode());

                final JsonNode statusJSON = JSON_MAPPER.readTree(
                    statusResponse.body());

                // Parse the response
                final String statusGroup =
                    statusJSON.get("group").asText();
                final String statusCode = statusJSON.get("code").asText();
                final String statusHash = statusJSON.get("hash").asText();
                final String statusDeadline =
                    statusJSON.get("deadline").asText();

                System.out.printf("  Attempt %d:%n", attempt);
                System.out.printf("    Status: %s%n", statusGroup);
                System.out.printf("    Code: %s%n", statusCode);
                System.out.printf("    Hash: %s%n", statusHash);
                System.out.printf("    Deadline: %s%n", statusDeadline);

                // Check if the transaction has been confirmed
                if ("confirmed".equals(statusGroup)) {
                    System.out.println("\nTransaction confirmed!");
                    return true;
                }

                // Check if the transaction failed
                if ("failed".equals(statusGroup)) {
                    System.out.printf(
                        "%nTransaction failed with code: %s%n",
                        statusCode);
                    throw new IOException(
                        "Transaction failed: " + statusCode);
                }
            }

            // Wait before next attempt (except on last attempt)
            if (attempt < maxAttempts)
                Thread.sleep(waitSeconds * 1000L);

        }

        System.out.printf(
            "%nTransaction not confirmed after %d attempts%n",
            maxAttempts);
        throw new IOException(
            "Transaction " + txHash + " not confirmed in time"
        );
    }
}

Download source

The snippet uses the NODE_URL environment variable to set the Symbol API node. If no value is provided, a default one is used.

Code Explanation⚓︎

Finding the Transaction Hash⚓︎

11
12
transaction_hash = os.getenv("TRANSACTION_HASH",
    "2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA")

7
8
const transactionHash = process.env.TRANSACTION_HASH ||
    '2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA';

38
39
40
41
        final String transactionHash =
            System.getenv().getOrDefault("TRANSACTION_HASH",
            "2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF95236534"
                + "06E04C7EA");

To monitor a transaction, you need its hash, which is generated after signing. The hash uniquely identifies the transaction on the Symbol network.

This tutorial uses a sample transaction hash to demonstrate the monitoring. You can provide your own hash by setting the TRANSACTION_HASH environment variable when running the code.

In practice, you would obtain this hash immediately after signing a transaction (see the Transfer tutorial for an example) and use it to track its status.

Querying the Status Endpoint⚓︎

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
def wait_for_transaction_confirmation(
    tx_hash, max_attempts=60, wait_seconds=2
):
    """
    Poll the transaction status endpoint until the transaction
    is confirmed.

    Args:
        tx_hash: The hash of the transaction to monitor
        max_attempts: Maximum number of polling attempts for confirmation
        wait_seconds: Seconds to wait between attempts

    Returns:
        True if transaction was confirmed
    """
    status_path = f"/transactionStatus/{tx_hash}"
    print("\nWaiting for transaction confirmation")
    print(f"Polling {status_path}")

    for attempt in range(1, max_attempts + 1):
        try:
            # Query the transaction status endpoint
            url = f"{NODE_URL}{status_path}"
            with urllib.request.urlopen(url) as response:
                response_json = json.loads(response.read().decode())

                # Parse the response
                status_group = response_json["group"]
                status_code = response_json["code"]
                status_hash = response_json["hash"]
                status_deadline = response_json["deadline"]

                print(f"  Attempt {attempt}:")
                print(f"    Status: {status_group}")
                print(f"    Code: {status_code}")
                print(f"    Hash: {status_hash}")
                print(f"    Deadline: {status_deadline}")

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
 * Poll the transaction status endpoint until it is confirmed.
 * @param {string} txHash - The hash of the transaction to monitor
 * @param {number} maxAttempts - Maximum number of polling attempts
 *   for confirmation
 * @param {number} waitSeconds - Seconds to wait between attempts
 * @returns {boolean} True if transaction was confirmed
 */
async function waitForTransactionConfirmation(
    txHash,
    maxAttempts = 60,
    waitSeconds = 2
) {
    const statusPath = `/transactionStatus/${txHash}`;
    console.log('\nWaiting for transaction confirmation');
    console.log(`Polling ${statusPath}`);

    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
            // Query the transaction status endpoint
            const statusResponse =
                await fetch(`${NODE_URL}${statusPath}`);

            if (!statusResponse.ok) {
                const status = statusResponse.status;
                const statusText = statusResponse.statusText;
                const error = new Error(`HTTP ${status}: ${statusText}`);
                error.status = statusResponse.status;
                throw error;
            }

            const statusJSON = await statusResponse.json();

            // Parse the response
            const statusGroup = statusJSON.group;
            const statusCode = statusJSON.code;
            const statusHash = statusJSON.hash;
            const statusDeadline = statusJSON.deadline;

            console.log(`  Attempt ${attempt}:`);
            console.log(`    Status: ${statusGroup}`);
            console.log(`    Code: ${statusCode}`);
            console.log(`    Hash: ${statusHash}`);
            console.log(`    Deadline: ${statusDeadline}`);

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
    /**
     * Poll the transaction status endpoint until it is confirmed.
     * @param txHash The hash of the transaction to monitor
     * @param maxAttempts Maximum number of polling attempts
     *   for confirmation
     * @param waitSeconds Seconds to wait between attempts
     * @return True if transaction was confirmed
     */
    private boolean waitForTransactionConfirmation(
        final String txHash,
        final int maxAttempts,
        final int waitSeconds
    ) throws IOException, InterruptedException {
        final String statusPath = "/transactionStatus/" + txHash;
        System.out.println("\nWaiting for transaction confirmation");
        System.out.printf("Polling %s%n", statusPath);

        for (int attempt = 1; attempt <= maxAttempts; ++attempt) {
            // Query the transaction status endpoint
            final HttpRequest statusRequest = HttpRequest.newBuilder(
                URI.create(NODE_URL + statusPath)).GET().build();
            final HttpResponse<String> statusResponse = HTTP_CLIENT.send(
                statusRequest, BodyHandlers.ofString());

            if (404 == statusResponse.statusCode()) {
                System.out.printf(
                    "  Attempt %d: Transaction status not yet available%n",
                    attempt);
            }
            else {
                if (statusResponse.statusCode() / 100 != 2)
                    throw new IOException(
                        "HTTP " + statusResponse.statusCode());

                final JsonNode statusJSON = JSON_MAPPER.readTree(
                    statusResponse.body());

                // Parse the response
                final String statusGroup =
                    statusJSON.get("group").asText();
                final String statusCode = statusJSON.get("code").asText();
                final String statusHash = statusJSON.get("hash").asText();
                final String statusDeadline =
                    statusJSON.get("deadline").asText();

                System.out.printf("  Attempt %d:%n", attempt);
                System.out.printf("    Status: %s%n", statusGroup);
                System.out.printf("    Code: %s%n", statusCode);
                System.out.printf("    Hash: %s%n", statusHash);
                System.out.printf("    Deadline: %s%n", statusDeadline);

The function is the core of this tutorial. It monitors a transaction until it is confirmed or fails.

It uses a for loop to check the transaction status up to 60 times by default (2 minutes with 2-second intervals between attempts). This loop structure ensures that monitoring will eventually stop, even if the transaction never confirms.

On each attempt, the function queries the /transactionStatus/{hash} GET endpoint, which returns information about the transaction's current state.

The response includes:

  • Group: The transaction's current status group. Possible values:

    Group Meaning
    unconfirmed The transaction is in the unconfirmed pool waiting to be included in a block.
    confirmed The transaction has been included in a block.
    failed The transaction failed validation and has been rejected.
    partial For bonded aggregate transactions waiting for cosignatures.

  • Code: A status code providing more details (for example, Success or specific error codes). See the TransactionStatusEnum schema for all possible values.

  • Hash: The transaction hash being monitored.
  • Deadline: The transaction's deadline in network time.

The function displays all these fields on each polling attempt so you can see how the transaction progresses through states.

Checking for Confirmation⚓︎

55
56
57
58
                # Check if the transaction has been confirmed
                if status_group == "confirmed":
                    print("\nTransaction confirmed!")
                    return True

57
58
59
60
61
            // Check if the transaction has been confirmed
            if ('confirmed' === statusGroup) {
                console.log('\nTransaction confirmed!');
                return true;
            }

101
102
103
104
105
                // Check if the transaction has been confirmed
                if ("confirmed".equals(statusGroup)) {
                    System.out.println("\nTransaction confirmed!");
                    return true;
                }

After parsing the response, the function checks the group field. If it is confirmed, the transaction was successfully included in a block through harvesting, and the function returns successfully.

Confirmed transactions can still be reversed

A confirmed transaction has been included in a block, but it is not yet irreversible. Only finalization makes a transaction final, when the block containing it is finalized by the network. Until then, rollbacks remain possible.

Checking for Failure⚓︎

60
61
62
63
64
65
66
67
                # Check if the transaction failed
                if status_group == "failed":
                    print(
                        f"\nTransaction failed with code: {status_code}"
                    )
                    raise RuntimeError(
                        f"Transaction failed: {status_code}"
                    )

63
64
65
66
67
68
69
            // Check if the transaction failed
            if ('failed' === statusGroup) {
                console.log(
                    `\nTransaction failed with code: ${statusCode}`
                );
                throw new Error(`Transaction failed: ${statusCode}`);
            }

107
108
109
110
111
112
113
114
                // Check if the transaction failed
                if ("failed".equals(statusGroup)) {
                    System.out.printf(
                        "%nTransaction failed with code: %s%n",
                        statusCode);
                    throw new IOException(
                        "Transaction failed: " + statusCode);
                }

If the transaction status group is failed, the function raises an error with the status code.

Common reasons include insufficient balance, invalid signatures, or deadline expiration. Failed transactions are rejected during validation and will not be included in a block.

See TransactionStatusEnum for all possible codes.

Handling Unknown Status⚓︎

69
70
71
72
73
74
75
76
        except urllib.error.HTTPError as err:
            if err.status == 404:
                print(
                    f"  Attempt {attempt}: Transaction status not "
                    "yet available"
                )
            else:
                raise

71
72
73
74
75
76
77
78
79
80
        } catch (error) {
            if (404 === error.status) {
                console.log(
                    `  Attempt ${attempt}: Transaction status not yet ` +
                    'available'
                );
            } else {
                throw error;
            }
        }

74
75
76
77
78
            if (404 == statusResponse.statusCode()) {
                System.out.printf(
                    "  Attempt %d: Transaction status not yet available%n",
                    attempt);
            }

If the endpoint returns HTTP 404, the transaction status is not yet available. This can happen immediately after announcing a transaction, before the node processes it, or if the hash is invalid. The function handles this case by logging the attempt and continuing to poll.

For any other error (such as connectivity issues or failed transactions), the function re-raises the exception immediately.

Waiting Between Attempts⚓︎

78
79
80
        # Wait before next attempt (except on last attempt)
        if attempt < max_attempts:
            time.sleep(wait_seconds)

82
83
84
85
86
87
        // Wait before next attempt (except on last attempt)
        if (attempt < maxAttempts) {
            await new Promise(resolve => {
                setTimeout(resolve, waitSeconds * 1000);
            });
        }

117
118
119
            // Wait before next attempt (except on last attempt)
            if (attempt < maxAttempts)
                Thread.sleep(waitSeconds * 1000L);

Between polling attempts, the function waits for a configurable delay (default: 2 seconds). This prevents overwhelming the node with requests and allows time for network processing.

Handling Timeouts⚓︎

82
83
84
85
    print(f"\nTransaction not confirmed after {max_attempts} attempts")
    raise RuntimeError(
        f"Transaction {transaction_hash} not confirmed in time"
    )

90
91
92
93
94
95
    console.log(
        `\nTransaction not confirmed after ${maxAttempts} attempts`
    );
    throw new Error(
        `Transaction ${txHash} not confirmed in time`
    );

123
124
125
126
127
128
        System.out.printf(
            "%nTransaction not confirmed after %d attempts%n",
            maxAttempts);
        throw new IOException(
            "Transaction " + txHash + " not confirmed in time"
        );

If the transaction is not confirmed after the specified number of attempts, the function raises a RuntimeError explaining the problem.

This ensures that the calling code is aware that the transaction didn't complete in the expected timeframe and can take appropriate action, such as:

  • Retrying the transaction announcement
  • Alerting the user
  • Logging the issue for investigation

Output⚓︎

The following output shows a typical run monitoring a transaction as it moves from unconfirmed to confirmed:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Using node https://reference.symboltest.net:3001
Monitoring transaction: 2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA

Waiting for transaction confirmation
Polling /transactionStatus/2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA
  Attempt 1: Transaction status not yet available
  Attempt 2: Transaction status not yet available
  Attempt 3:
    Status: unconfirmed
    Code: Success
    Hash: 2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA
    Deadline: 47578965854
  Attempt 4:
    Status: unconfirmed
    Code: Success
    Hash: 2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA
    Deadline: 47578965854
  Attempt 5:
    Status: confirmed
    Code: Success
    Hash: 2B6D3B5232E06B9D32682F518C765301FCF9716BFA1EEEF9523653406E04C7EA
    Deadline: 47578965854

Transaction confirmed!

Some highlights from the output:

  • Transaction hash (line 2): The hash of the transaction to monitor, which uniquely identifies it on the network.

  • Polling start (line 4): Polling begins on the /transactionStatus/{hash} GET endpoint. During the first attempts (lines 6-7) the node has not yet started processing the transaction.

  • Unconfirmed status (lines 8-17): The transaction enters the unconfirmed pool and waits to be included in a block.

  • Confirmation (line 19): The status changes to confirmed, meaning the transaction has been included in a block.

The number of attempts and timing vary depending on network conditions and block production rate. On the Symbol network, blocks are typically produced every 30 seconds, so you may see several unconfirmed status responses before the transaction is confirmed.

Once confirmed, you can get additional details such as the block height where the transaction was included by querying /transactions/confirmed/{transactionId} GET with the transaction hash.

To see the transaction from the network's perspective, visit the Symbol Testnet Explorer and search for the transaction hash.

Conclusion⚓︎

This tutorial showed how to:

Step Related documentation
Query the status endpoint /transactionStatus/{hash} GET
Check for confirmation TransactionStatusEnum
Check for failure TransactionStatusEnum

Next steps⚓︎

For production applications, consider these improvements:

  • Wait for finalization: Verify that the block containing the transaction has been finalized to ensure it is truly irreversible. See Querying Chain and Finalization Height.
  • Prove transaction inclusion: Verify cryptographically that a transaction is part of a block using a Merkle proof. See Proving a Transaction's Inclusion in a Block.
  • Query multiple nodes: Check status and finalization across several nodes for greater reliability and protection against single-node issues.
  • Use WebSockets: Replace polling with WebSocket subscriptions for real-time updates without repeated API calls. See the Listening to Transaction Flow WebSocket tutorial.