JPTC Trading Bot: Complete Automation for Forex & Prop Firm Accounts

Why Manual Trading Fails at Scale

If you have ever tried to manage three or four prop firm accounts at once, you already know the pain. You spot an entry on your FTMO challenge account, switch to FundedNext, enter the same trade with adjusted lot sizing, then move to FXify and do it again. By the time you finish, the price has moved. You missed the entry on the second account, and the third one got a worse fill.

That latency gap between accounts is where traders lose money. It is not a skill problem—it is an execution bottleneck. JPTC was built to solve exactly this: a trading bot automation system that connects your strategy to every prop firm account through a single pipeline, using Discord as the command interface and a REST API for programmatic control.

No more copy-pasting lot sizes. No more switching between terminals. You issue one signal, and JPTC replicates it across every connected account in milliseconds. The rest of this article breaks down exactly how the system works, how to set it up, and how you can earn money by referring other traders to the platform.

How JPTC Works: From API to Discord Integration

At its core, JPTC is a three-layer system. Understanding each layer helps you troubleshoot, extend, and get the most out of the platform.

Layer 1: The Signal Source

Every trade starts as a signal. That signal can come from multiple sources:

• Discord bot commands — Type a structured command in your private Discord channel, and the JPTC forex bot Discord integration parses it into a trade instruction.
• REST API calls — Send a POST request from any application, webhook, or custom script. This is the backbone for algo trading strategies that run on external servers.
• MQL5 Expert Advisors — If your strategy lives inside MetaTrader, the EA sends signals directly to the JPTC API via HTTP requests embedded in the MQL5 code.

Layer 2: The Execution Engine

Signals land in the JPTC execution engine, a Node.js service that handles authentication, validation, and routing. Here is what happens in sequence:

1. The engine authenticates the incoming request using your API token.
2. It validates the trade parameters: symbol, direction, lot size, stop loss, take profit.
3. The risk manager checks the signal against each connected account's rules—maximum drawdown, daily loss limits, position sizing constraints.
4. Validated trades are dispatched to every linked broker account in parallel.

Layer 3: The Admin Dashboard

The JPTC admin dashboard gives you real-time visibility into every trade across all connected accounts. You can see execution timestamps, fill prices, slippage metrics, and account equity curves. The dashboard is built with React and Vite, backed by a Supabase database for real-time subscriptions. When a trade executes, you see the update within seconds—no manual refresh needed.

The dashboard also supports 6 languages (English, Dutch, Portuguese, Spanish, German, and French), making it accessible to traders across Europe and beyond.

Trade Copier Setup for Multiple Prop Firm Accounts

The trade copier is the most practical feature in JPTC for anyone running prop firm challenges. Here is how the trade copier setup works in practice.

Connecting Your Accounts

Each prop firm account connects to JPTC through an API token. You generate this token from your broker or prop firm dashboard (FTMO, FundedNext, and FXify all support API access on MetaTrader accounts). Then you add the token in the JPTC admin panel under Account Connections.

The system supports an arbitrary number of accounts. Whether you have two or twenty, the execution engine fans out signals to all of them simultaneously.

Per-Account Configuration

Not every account should trade the same lot size. A $100k FTMO challenge has different risk parameters than a $10k FundedNext account. JPTC handles this with per-account configuration:

• Lot multiplier — Scale the master signal's lot size up or down per account.
• Max daily loss cap — Automatically stop trading on an account if it approaches the prop firm's daily loss limit.
• Symbol filtering — Exclude specific pairs on specific accounts (useful if a prop firm restricts certain instruments).
• Slippage tolerance — Set a maximum acceptable slippage in pips; if the fill deviates beyond this, the trade is rejected.

Monitoring Execution Quality

Execution latency matters when prop firms measure your drawdown to the cent. The admin dashboard tracks the time between signal dispatch and broker fill for every trade, on every account. If one account consistently shows higher latency, you know to investigate that broker's infrastructure.

Node.js & MQL5: Why This Combination Works

Building a Node.js trading bot that communicates with MetaTrader might seem unusual if you come from a pure MQL5 background. But this architecture is deliberate, and there are good reasons for each technology choice.

Why Node.js for the Execution Layer

Node.js is non-blocking and event-driven. When a signal arrives, the engine does not wait for one account to fill before sending to the next. It dispatches all requests concurrently using async/await patterns and resolves them in parallel. That is critical when you have ten accounts and need sub-second execution on all of them.

The ecosystem also matters. Supabase has a mature JavaScript SDK for real-time database subscriptions. Discord.js handles the bot integration. Express (or Fastify) serves the REST API. All of these are battle-tested Node.js libraries that JPTC builds on top of.

Here is a simplified example of how the execution engine dispatches a trade signal to multiple accounts:

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_KEY
);

async function dispatchTrade(signal) {
  // Fetch all active accounts from Supabase
  const { data: accounts } = await supabase
    .from('connected_accounts')
    .select('*')
    .eq('status', 'active');

  // Dispatch to all accounts in parallel
  const results = await Promise.allSettled(
    accounts.map(account => executeTrade(account, signal))
  );

  // Log results to the dashboard
  for (const [i, result] of results.entries()) {
    await supabase.from('trade_logs').insert({
      account_id: accounts[i].id,
      signal_id: signal.id,
      status: result.status,
      fill_price: result.value?.price ?? null,
      latency_ms: result.value?.latency ?? null,
      error: result.reason?.message ?? null,
    });
  }
}

async function executeTrade(account, signal) {
  const start = Date.now();
  const adjustedLot = signal.lot * account.lot_multiplier;

  // Validate against account risk rules
  if (account.daily_loss_used + estimateRisk(adjustedLot) > account.max_daily_loss) {
    throw new Error(`Daily loss limit reached for ${account.name}`);
  }

  const response = await fetch(account.broker_api_url, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${account.api_token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      symbol: signal.symbol,
      side: signal.direction,
      volume: adjustedLot,
      sl: signal.stop_loss,
      tp: signal.take_profit,
    }),
  });

  const data = await response.json();
  return { price: data.fill_price, latency: Date.now() - start };
}

Why MQL5 on the Strategy Side

MetaTrader is where most forex strategies run. MQL5 Expert Advisors have direct access to tick data, chart patterns, and indicator calculations without any external dependency. Rather than trying to replace that, JPTC adds a thin HTTP layer on top of it. The EA runs your strategy logic, and when it decides to trade, it fires an HTTP request to the JPTC API instead of placing the trade locally.

This means your strategy stays in MetaTrader where it belongs, but execution scales across every connected account. Here is what the MQL5 bot API integration looks like inside an EA:

// JPTC Signal Sender for MetaTrader 5
#include <Trade\Trade.mqh>

input string JPTC_API_URL   = "https://api.jptradingcapital.com/v1/signal";
input string JPTC_API_TOKEN = ""; // Your API token
input double BaseLotSize    = 0.1;

int OnInit() {
   Print("JPTC Signal Sender initialized");
   return(INIT_SUCCEEDED);
}

void SendSignalToJPTC(string symbol, string direction,
                      double lot, double sl, double tp) {
   string payload = StringFormat(
      "{\"symbol\":\"%s\",\"direction\":\"%s\","
      "\"lot\":%.2f,\"stop_loss\":%.5f,\"take_profit\":%.5f}",
      symbol, direction, lot, sl, tp
   );

   char post_data[];
   char result_data[];
   string result_headers;

   StringToCharArray(payload, post_data, 0, WHOLE_ARRAY, CP_UTF8);

   string headers = "Content-Type: application/json\r\n"
                  + "Authorization: Bearer " + JPTC_API_TOKEN + "\r\n";

   int res = WebRequest(
      "POST", JPTC_API_URL, headers,
      5000, post_data, result_data, result_headers
   );

   if (res == 200)
      Print("JPTC signal dispatched: ", symbol, " ", direction);
   else
      Print("JPTC signal failed, HTTP code: ", res);
}

void OnTick() {
   // Your strategy logic here
   // Example: simple moving average crossover
   double ma_fast = iMA(_Symbol, PERIOD_H1, 20, 0, MODE_EMA, PRICE_CLOSE);
   double ma_slow = iMA(_Symbol, PERIOD_H1, 50, 0, MODE_EMA, PRICE_CLOSE);

   static bool was_above = false;
   bool is_above = ma_fast > ma_slow;

   if (is_above && !was_above) {
      // Bullish crossover detected
      double sl = SymbolInfoDouble(_Symbol, SYMBOL_BID) - 0.0050;
      double tp = SymbolInfoDouble(_Symbol, SYMBOL_BID) + 0.0100;
      SendSignalToJPTC(_Symbol, "BUY", BaseLotSize, sl, tp);
   }

   was_above = is_above;
}

The Bridge Between Both Worlds

This separation of concerns—MQL5 for strategy, Node.js for execution and infrastructure—gives you flexibility that a monolithic MQL5 setup cannot match. You can swap strategies without rebuilding your execution pipeline. You can add new accounts without modifying your EA. And you can monitor everything from a web dashboard instead of staring at multiple MetaTrader windows.

Affiliate Marketing with JPTC: Generating Passive Income

Beyond trading, JPTC includes a built-in forex affiliate program that pays real commissions for referring new traders. This is not an afterthought—the referral system is integrated directly into the admin dashboard with full tracking and transparency.

How the Referral Program Works

Every JPTC user gets a unique referral link. When someone signs up through that link and becomes an active customer, you earn a flat commission. Here is the structure:

• Base commission: A fixed payout per referred customer who activates their account.
• Milestone bonuses: Every five successful referrals unlock a bonus payout on top of the per-referral commission.
• Real-time tracking: The affiliate dashboard shows clicks, signups, conversions, and cumulative earnings.

Who Should Promote JPTC

The affiliate program works well for several types of people:

• Forex educators who have an audience of aspiring traders looking for prop firm solutions.
• Discord community owners who run trading signal groups and can recommend JPTC's automation tools.
• Content creators on YouTube, TikTok, or Twitter/X who cover forex and prop firm topics.
• Existing JPTC users who are happy with the platform and want to share it with their trading network.

The referral tracking is handled server-side through Supabase, so there is no reliance on third-party cookies or browser storage. Your referrals are attributed reliably, even if the person signs up on a different device days later.

Security & Compliance: Tokens, Accounts, and Data

When you connect a trading account to any third-party system, security is the first question you should ask. Here is how JPTC handles it.

API Token Architecture

JPTC never asks for or stores your broker login credentials (username and password). Instead, it uses scoped API tokens that you generate from your broker or prop firm dashboard. These tokens typically have the following properties:

• Trade execution only: The token can place, modify, and close trades. It cannot initiate withdrawals, change account settings, or access personal information.
• Revocable at any time: If you want to disconnect an account, you revoke the token from your broker dashboard. JPTC immediately loses access.
• Encrypted at rest: Tokens stored in the Supabase database are encrypted. They are only decrypted in memory during trade execution and are never logged in plaintext.

Account Isolation

Each connected account operates in its own execution context. If one account encounters an error (broker downtime, rejected order, insufficient margin), it does not affect the other accounts in the pipeline. The execution engine uses Promise.allSettled rather than Promise.all specifically for this reason—one rejection does not cancel the rest.

Data Handling

JPTC's backend runs on Supabase, which provides Row Level Security (RLS) out of the box. This means:

• Your trade logs are only visible to your authenticated session.
• Affiliate data is scoped to your user ID—you cannot see other affiliates' performance.
• Admin endpoints require elevated role verification before any data is returned.

Compliance with Prop Firm Rules

Prop firms like FTMO and FundedNext have specific rules about automation. Most allow it as long as you are not using a shared strategy with identical trade timing across thousands of accounts (which looks like copy-trading abuse). JPTC mitigates this by supporting per-account timing jitter and individual lot sizing, so each account's trade history looks distinct even when originating from the same signal.

Step-by-Step: Deploying JPTC

This section walks you through the full deployment process, from setting up the infrastructure to placing your first automated trade.

# Clone and install
git clone https://github.com/your-org/jptc-dashboard.git
cd jptc-dashboard
npm install

# Set environment variables
cp .env.example .env.local
# Edit .env.local with your Supabase URL, keys, and Discord config

# Run locally
npm run dev

# Deploy to Vercel
npx vercel --prod

# Build the web app
npm run build

# Sync with Capacitor
npx cap sync

# Open in Android Studio
npx cap open android

# Or open in Xcode for iOS
npx cap open ios

Advanced Configuration: Webhooks, Email, and Notifications

JPTC integrates with Resend for transactional email. This powers several automated notifications:

• Trade execution confirmations — Get an email every time a trade is placed across your accounts (configurable frequency to avoid inbox overload).
• Risk alerts — Receive an immediate notification if an account approaches its daily loss limit or maximum drawdown threshold.
• Affiliate milestone alerts — Get notified when you hit a referral milestone and earn a bonus.
• Weekly performance summaries — An automated digest showing P/L, win rate, and account status across all connected accounts.

You can also configure webhook URLs for custom integrations. Every trade event publishes a JSON payload that you can consume in Zapier, Make, or your own backend:

{
  "event": "trade.executed",
  "timestamp": "2026-04-06T14:32:18.442Z",
  "signal": {
    "id": "sig_a8f3c91d",
    "symbol": "EURUSD",
    "direction": "BUY",
    "lot": 0.1,
    "stop_loss": 1.085,
    "take_profit": 1.095
  },
  "executions": [
    {
      "account": "FTMO-100K",
      "status": "filled",
      "fill_price": 1.09012,
      "adjusted_lot": 0.2,
      "latency_ms": 147
    },
    {
      "account": "FundedNext-50K",
      "status": "filled",
      "fill_price": 1.09014,
      "adjusted_lot": 0.1,
      "latency_ms": 163
    }
  ]
}

This payload structure makes it straightforward to build external dashboards, alert systems, or even feed data into a Google Sheet for manual analysis.

Performance and Scaling Considerations

Running a prop firm account automation system at scale introduces real engineering challenges. Here is how JPTC addresses the most common ones.

Execution Latency

The round trip from signal receipt to broker fill depends on three factors: your server location, the broker's API response time, and network conditions. JPTC minimizes the first factor by deploying on Vercel's edge network, which places the execution engine close to major financial data centers. For the Amsterdam, London, and New York regions, typical signal-to-dispatch latency is under 50ms.

Rate Limiting and Backpressure

Brokers impose rate limits on their APIs. If you send 20 trade requests per second, some will get throttled. JPTC handles this with a configurable queue that respects per-broker rate limits. Requests are batched efficiently, and if a broker responds with a rate-limit header, the engine backs off automatically.

Database Performance

Supabase (PostgreSQL under the hood) handles the trade log volume well for typical JPTC deployments. If you are processing thousands of trades per day across dozens of accounts, consider enabling Supabase's read replicas and connection pooling to keep dashboard queries fast.

Scaling the Discord Bot

If your Discord server has hundreds of users sending trade commands simultaneously, the bot scales horizontally using Discord's sharding API. Each shard handles a subset of guilds, and signals are forwarded to the same execution engine regardless of which shard received them.