日本語版 (Japanese version)

If you've ever tried to integrate blockchain functionality into an application, you're writing the same patterns over and over: fetch data from the API, parse responses, handle errors, poll for updates, connect to external services ...

The code gets long.

You extract some functions to make it reusable.

Then you have to maintain the infrastructure: keep servers running, monitor logs, handle deployments, manage dependencies.

What if you didn't have to write or maintain most of that?

What I built

An library of nodes for Symbol that lets you query transactions through a visual workflow.

This is a demo focused on monitoring blockchain activity, but the approach can be expanded to include sending transactions, managing accounts, and more.

For those unfamiliar: n8n is an open-source workflow automation platform (think Zapier, but self-hosted). You drag nodes onto a canvas, connect them, and they run. Each node does one thing: fetch data, transform it, call an API, send a notification, whatever.

Quick note for those new to Symbol: unlike Ethereum or other smart contract platforms, Symbol is API-driven. You interact with it through REST endpoints, not by deploying contracts. No contract compilation, just straightforward HTTP calls. Which is exactly what n8n excels at.

What's included in this demo:

Symbol get transactions node: Query confirmed transactions for any address
Example workflow for real-time monitoring and Slack notifications
Full source code ready for extending with additional nodes (transfers, advanced filtering, account info, etc.)

Why I built this

Most Symbol integrations are 80% boilerplate and 20% business logic.

Here's what monitoring a Symbol address looks like in raw code:

// Poll every 5 minutes
setInterval(async () => {
    try {
        // Build query parameters
        const params = new URLSearchParams({
            recipientAddress: MONITORED_ADDRESS,
            type: '16724', // Transfer transactions
            pageSize: '10',
            order: 'desc'
        });

        // Fetch transactions
        const response = await fetch(`${NODE_URL}/transactions/confirmed?${params}`);
        const transactions = await response.json();

        // Check if any new transactions
        if (transactions.data.length > 0) {
            // Parse transaction data
            const tx = transactions.data[0].transaction;
            const amount = tx.mosaics[0]?.amount / 1000000; // Convert to XYM
            const sender = tx.signerPublicKey;
            const hash = transactions.data[0].meta.hash;
            const height = transactions.data[0].meta.height;

            // Send to Slack
            await fetch(SLACK_WEBHOOK_URL, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    text: `Payment Received!\n\nAmount: ${amount} XYM\nFrom: ${sender}\nTx Hash: ${hash}\nBlock Height: ${height}`
                })
            });
        }
    } catch (error) {
        // Handle errors, log, retry, etc.
        console.error('Error:', error);
    }
}, 5 * 60 * 1000);

// Keep process alive, handle crashes, manage rate limits...

That's a simplified version. In reality, you also need to:

Track which transactions you've already processed (database or cache)
Handle rate limits and network errors
Manage the server/container running this code
Set up logging and monitoring
Deploy it somewhere and keep it running

With n8n? Seven visual nodes.

The infrastructure, retry logic, and monitoring are already handled.

Use case: Real-time payment monitoring

Suppose you run a business that accepts XYM payments.

You want to know when someone sends you XYM so you can process orders, update databases, or notify your team.

Here's how it works:

Schedule trigger runs every 5 minutes (or 30 seconds, or hourly)
Get next height retrieves the last processed block height from workflow storage (or 0 on first run)
Symbol get transactions queries the API for transactions from that height onwards
Track height updates the stored height for the next run
IF node checks if any transactions were returned
Prepare message formats transaction details into a readable message
Slack node sends the notification

The workflow runs automatically in n8n's environment, handles retries, prevents duplicate notifications, and you can see exactly what's happening at each step with visual feedback.

Example Slack message:

New transaction

Amount: 50000000 (atomic)
Mosaic ID: E74B99BA41F4AFEE
From: 87DA603E7BE5656C45692D5FC7F6D0EF8F24BB7A5C10ED5FDA8C5CFBC49FCBC8
To: 9850BF0FD1A45FCEE211B57D0FE2B6421EB81979814F6292
Message: Order #12345
Tx Hash: 6E0DBB75...
Block Height: 2952796

Note: The workflow tracks which transactions have been processed by storing the last processed block height in n8n's workflow static data. This prevents duplicate notifications when polling repeatedly.

Most blockchain monitoring involves fetching data, filtering it, and triggering actions. By making Symbol accessible through n8n, you can build these workflows in minutes. Projects with limited resources can ship faster. Hackathon teams can focus on ideas instead of infrastructure.

And because n8n is open source and self-hosted, you're not locked into a SaaS platform.

You can extend this easily: add a webhook to your order system, update a Google Sheet, send an email receipt, log to a database, or trigger any other action. n8n has 400+ integrations built in.

More ideas for your workflows

This demo focuses on monitoring transactions, but the same approach unlocks many possibilities:

Automated accounting: Generate invoices in QuickBooks, log to Airtable, and email receipts when payments arrive.
Token-gated access: Verify token holdings when users join your Discord or community platform and assign roles automatically.
Transparent donations: Update live dashboards, post thank-you messages on social media, compile monthly impact reports.
Content delivery: Verify payments and automatically deliver digital products, course access, or download links.
Escrow workflows: Monitor multi-signature accounts and trigger actions off-chain when conditions are met.
Cross-chain bridges: Detect Symbol transactions and trigger corresponding actions on other networks.
Customer loyalty: Reward customers based on transaction history.
Supply chain tracking: Monitor mosaic transfers between addresses to track product movement.

Education: Teaching blockchain visually

Image generated with Gemini

When explaining blockchain to students or newcomers, concepts like transactions and confirmations feel abstract.

Instead, they could learn by building visual workflows using the testnet. Students can send test transactions and immediately see them flow through the system.

Universities could use this to teach blockchain fundamentals without requiring students to become SDK experts first. They see the data, the filtering, the real-time updates (everything becomes tangible).

Expanding this demo

Right now this is a single node focused on querying transactions by address.
Here's what could be added to make it a full Symbol integration:

Transaction nodes: Transfer, sign, and announce nodes for sending transactions
Account info node: Fetch account balance, owned mosaics, and metadata
More transaction types: Support for namespace, mosaic definition, metadata, and multi-signature transactions
Wait for confirmation node: Poll transaction status until confirmed
Block info node: Query block height and fetch block data
Metadata node: Read and write account, mosaic, or namespace metadata

Each node is about 200-300 lines of TypeScript. The foundation is built and ready for expansion.

Try it yourself

Prerequisites:

Node.js 20+ (install with nvm install 20 && nvm use 20)

Installation:

# Clone the repo
git clone https://github.com/zero4862/n8n-nodes-symbol.git
cd n8n-nodes-symbol

# Install dependencies and build
npm install
npm run build

# Package the node
npm pack

# Save the current path
PACKAGE_PATH=$(pwd)/n8n-nodes-symbol-0.1.0.tgz

# Install the package to n8n
mkdir -p ~/.n8n/nodes
cd ~/.n8n/nodes
npm install $PACKAGE_PATH

# Install n8n (if not already installed)
npm install n8n -g

# Start n8n
n8n start

Setup:

Open http://localhost:5678 in your browser
Create an owner account (first-time setup)
Create a new workflow:
Click the three dots menu → Import from File:
Select examples/monitor-and-notify.json from the cloned repo
Configure the Symbol Get Transactions node and Slack webhook with your values:
Click Active (toggle in the top right) to start the workflow

Within minutes, you'll see blockchain data flowing into your notifications.

Support this work

If you find this useful, star the repo on GitHub. It helps with visibility and signals there's interest in expanding this integration with more nodes (multisig, namespaces, metadata, etc.).

Find me on X as @zero48622767321. If you build something interesting with these nodes, let me know.