JPTC Trading Bot: Volledige Automatisering voor Forex & Prop Firm Accounts

Introductie: waarom trading bot automatiseren?

Iedere trader die meerdere prop firm accounts beheert kent het probleem: je opent een positie op FTMO, moet dezelfde trade handmatig kopieren naar FundedNext, en vervolgens nog een keer naar FXify. Tegen de tijd dat je klaar bent, is de entry al verschoven. Slippage, gemiste trades en menselijke fouten kosten reeel geld.

JPTC (JPTradingCapital) lost dit op met een geintegreerde aanpak: een trading bot automatiseren via Discord signalen, broker API's en een gecentraliseerd dashboard. Geen handmatig kopieerwerk meer. Eenmaal geconfigureerd, worden trades binnen milliseconden gespiegeld naar al je accounts, inclusief aangepast risicomanagement per account.

In dit artikel loop je door de complete technische architectuur van JPTC: hoe de Node.js trading bot communiceert met Discord, hoe MQL5 Expert Advisors de signalen uitvoeren, en hoe je met het affiliate programma passief inkomen genereert terwijl het systeem draait.

Hoe JPTC werkt: van API tot Discord integratie

De kern van JPTC is een drie-lagen architectuur die signalen omzet in uitgevoerde trades. Hier volgt hoe elk onderdeel samenwerkt.

Laag 1: Signaal generatie

Een master trader voert trades uit op zijn eigen account. Elke positie wordt geregistreerd door een MQL5 Expert Advisor die draait op de MetaTrader terminal. Dit EA stuurt bij elke OrderSend, OrderModify en OrderClose een HTTP-request naar de JPTC API.

Laag 2: JPTC Backend (Supabase + Node.js)

De backend draait op Supabase voor database en authenticatie, gecombineerd met serverless functies op Vercel. Inkomende signalen worden gevalideerd tegen de API-token van de master trader, opgeslagen in de database en doorgestuurd naar de juiste kanalen.

De forex bot Discord integratie werkt via de Discord.js library. Zodra een signaal binnenkomt, publiceert de bot een geformatteerd bericht in een privechannel. Dit bericht bevat het valutapaar, richting, entry-prijs, stop-loss en take-profit niveaus. Gebruikers die geen API-connectie willen, kunnen signalen handmatig overnemen vanuit Discord.

// Inkomend trade signaal verwerken en naar Discord sturen
import { createClient } from '@supabase/supabase-js';
import { Client, EmbedBuilder } from 'discord.js';

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

export async function handleTradeSignal(req, res) {
  const { symbol, direction, entry, sl, tp, lotSize } = req.body;

  // Signaal opslaan in Supabase
  const { data, error } = await supabase
    .from('trade_signals')
    .insert({
      symbol,
      direction,
      entry_price: entry,
      stop_loss: sl,
      take_profit: tp,
      lot_size: lotSize,
      status: 'pending',
      created_at: new Date().toISOString()
    });

  if (error) return res.status(500).json({ error });

  // Discord embed aanmaken
  const embed = new EmbedBuilder()
    .setColor(direction === 'BUY' ? 0x34cf91 : 0xff4444)
    .setTitle(`${direction} ${symbol}`)
    .addFields(
      { name: 'Entry', value: `${entry}`, inline: true },
      { name: 'Stop Loss', value: `${sl}`, inline: true },
      { name: 'Take Profit', value: `${tp}`, inline: true }
    )
    .setTimestamp();

  await discordChannel.send({ embeds: [embed] });

  // Signaal doorsturen naar trade copier
  await dispatchToCopier(data[0]);

  return res.status(200).json({ success: true, signalId: data[0].id });
}

Laag 3: Uitvoering via Trade Copier

De trade copier ontvangt het signaal en voert het uit op alle geconnecteerde accounts. Per account zijn parameters instelbaar: lotgrootte-multiplier, maximale positiegrootte, paar-whitelist en drawdown-limiet. Dit betekent dat je op je FTMO-account met 0.5 lot kunt traden terwijl hetzelfde signaal op FundedNext met 1.0 lot wordt uitgevoerd.

Trade copier setup voor meerdere prop firm accounts

Het gelijktijdig beheren van meerdere prop firm accounts is waar de meeste traders vastlopen. Elke prop firm heeft eigen regels: maximale dagelijkse loss, drawdown-limieten, minimum handelsdagen. Een fout op een account kan weken werk ongedaan maken.

De JPTC trade copier setup is ontworpen rond dit probleem. Het systeem werkt met een master-slave model waarbij je volledige controle hebt over hoe signalen worden vertaald per account.

Account configuratie

Elke prop firm account wordt geregistreerd in het JPTC dashboard met de volgende parameters:

• Broker API credentials -- versleuteld opgeslagen in Supabase met RLS-policies
• Lot-multiplier -- pas de positiegrootte aan relatief aan het master signaal
• Max drawdown percentage -- het systeem stopt automatisch met kopieren wanneer de grens bereikt wordt
• Paar-filter -- selecteer welke valutaparen gekopieerd mogen worden
• Trading-uren -- beperk executie tot specifieke sessies (bijv. alleen London + New York)

// Voorbeeld: account configuratie voor trade copier
const accountConfig = {
  accountId: 'ftmo-challenge-001',
  broker: 'FTMO',
  apiEndpoint: process.env.FTMO_API_URL,
  credentials: {
    login: process.env.FTMO_LOGIN,
    server: 'FTMO-Server3'
  },
  riskSettings: {
    lotMultiplier: 0.5,      // Halve lotgrootte vs master
    maxDailyLoss: 4.5,       // Max 4.5% dagelijks verlies
    maxTotalDrawdown: 9.0,   // Max 9% totale drawdown
    maxOpenPositions: 3,     // Maximaal 3 posities tegelijk
  },
  filters: {
    allowedPairs: ['EURUSD', 'GBPUSD', 'XAUUSD'],
    tradingHours: { start: '08:00', end: '17:00', timezone: 'Europe/Amsterdam' },
    minRiskReward: 1.5      // Alleen trades met R:R >= 1.5
  }
};

export async function executeCopiedTrade(signal, config) {
  // Controleer of paar is toegestaan
  if (!config.filters.allowedPairs.includes(signal.symbol)) {
    return { skipped: true, reason: 'pair_not_allowed' };
  }

  // Bereken aangepaste lotgrootte
  const adjustedLot = signal.lotSize * config.riskSettings.lotMultiplier;

  // Controleer drawdown voor executie
  const currentDrawdown = await getAccountDrawdown(config.accountId);
  if (currentDrawdown >= config.riskSettings.maxTotalDrawdown) {
    return { skipped: true, reason: 'drawdown_limit_reached' };
  }

  // Trade uitvoeren via broker API
  const result = await brokerApi.placeOrder({
    symbol: signal.symbol,
    side: signal.direction,
    volume: adjustedLot,
    stopLoss: signal.stop_loss,
    takeProfit: signal.take_profit
  });

  return result;
}

Prop firm compliance monitoring

Het JPTC admin dashboard bevat real-time monitoring die specifiek is afgestemd op prop firm regels. Voor FTMO, FundedNext en FXify worden de volgende metrics continu berekend:

• Dagelijks verlies -- percentage van het startkapitaal, vergeleken met de prop firm limiet
• Totale drawdown -- met een waarschuwingssysteem dat triggers bij 70% en 90% van de limiet
• Minimum handelsdagen -- teller die bijhoudt hoeveel unieke tradingdagen zijn geregistreerd
• Profit target voortgang -- visuele voortgangsbalk richting het challenge-doel

Wanneer een account de drawdown-grens nadert, schakelt het systeem automatisch over naar een veiligheidsmodus: nieuwe kopieertrades worden gepauzeerd en er wordt een melding verstuurd via Discord en het dashboard.

Node.js & MQL5: waarom deze combinatie werkt

De keuze voor Node.js als backend en MQL5 als executielaag is bewust. Beide technologieen vullen elkaar aan op precies de punten die ertoe doen voor een trading bot automatiseren.

Node.js: de orchestratie-laag

Node.js is ideaal voor de JPTC backend om meerdere redenen. Ten eerste is het event-driven model perfect voor het afhandelen van real-time trade signalen. Een binnenkomend signaal moet snel worden verwerkt -- niet na een polling-interval van 5 seconden, maar direct. De non-blocking I/O van Node.js maakt dit mogelijk zonder threading-overhead.

Ten tweede integreert Node.js naadloos met het ecosysteem dat JPTC gebruikt: Supabase heeft een eersteklas JavaScript SDK, Discord.js is de meest volwassen bot-library, en Vercel serverless functies zijn native Node.js. Alles past samen zonder frankensteining van frameworks.

Ten derde maakt npm het triviaal om packages toe te voegen voor specifieke broker-integraties, WebSocket-connecties voor real-time data, en analytics-libraries voor performance tracking.

MQL5: de executie-laag

Aan de MetaTrader-kant draait MQL5 code die de brug vormt tussen het JPTC platform en de daadwerkelijke orderuitvoering. De MQL5 bot API wordt aangesproken via een Expert Advisor die twee taken heeft: trades van de master registreren en signalen van de copier uitvoeren.

//+------------------------------------------------------------------+
//| JPTCBridge.mq5 - Verbindt MetaTrader met JPTC API               |
//+------------------------------------------------------------------+
#property copyright "JPTradingCapital"
#property version   "2.10"

input string ApiUrl     = "https://api.jptradingcapital.com";
input string ApiToken   = "";  // Persoonlijke API token
input int    PollMs     = 500; // Poll-interval in milliseconden

int OnInit() {
   EventSetMillisecondTimer(PollMs);
   Print("JPTC Bridge gestart - poll interval: ", PollMs, "ms");
   return(INIT_SUCCEEDED);
}

void OnTimer() {
   // Haal pending signalen op van de JPTC API
   string response = HttpGet(ApiUrl + "/signals/pending", ApiToken);

   if (response == "") return;

   // Parse het signaal
   string symbol    = JsonGetString(response, "symbol");
   string direction = JsonGetString(response, "direction");
   double entry     = JsonGetDouble(response, "entry_price");
   double sl        = JsonGetDouble(response, "stop_loss");
   double tp        = JsonGetDouble(response, "take_profit");
   double lots      = JsonGetDouble(response, "lot_size");

   // Voer de trade uit
   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   request.action    = TRADE_ACTION_DEAL;
   request.symbol    = symbol;
   request.volume    = lots;
   request.type      = (direction == "BUY")
                        ? ORDER_TYPE_BUY
                        : ORDER_TYPE_SELL;
   request.price     = (direction == "BUY")
                        ? SymbolInfoDouble(symbol, SYMBOL_ASK)
                        : SymbolInfoDouble(symbol, SYMBOL_BID);
   request.sl        = sl;
   request.tp        = tp;
   request.deviation = 10;

   if (OrderSend(request, result)) {
      Print("JPTC Trade uitgevoerd: ", symbol, " ", direction);
      // Bevestig executie naar API
      HttpPost(ApiUrl + "/signals/confirm", ApiToken,
               "ticket=" + IntegerToString(result.order));
   } else {
      Print("JPTC Order mislukt: ", GetLastError());
   }
}

Waarom niet puur MQL5?

Een veelgestelde vraag: waarom niet alles in MQL5 bouwen? Het antwoord is schaalbaarheid. MQL5 is sterk in orderuitvoering en technische indicatoren, maar het is geen webframework. Probeer maar eens een REST API met authenticatie, een Discord bot en een database-connectie te bouwen in MQL5 -- het is technisch mogelijk via DLL-imports, maar de complexiteit en het onderhoud zijn disproportioneel.

Door Node.js te gebruiken voor orkestratie en MQL5 voor uitvoering, speelt elk onderdeel zijn sterkste kaart. De Node.js server handelt API-verzoeken af, beheert sessies, communiceert met Discord en schrijft naar de database. MQL5 doet waar het voor gemaakt is: snel en betrouwbaar orders plaatsen bij de broker.

Affiliate marketing met JPTC: passief inkomen genereren

Naast de technische tradingfuncties biedt JPTC een volledig geintegreerd forex affiliate marketing programma. Dit is geen externe plugin of third-party tracking -- het zit ingebakken in dezelfde Supabase database en hetzelfde dashboard dat je al gebruikt voor je tradingactiviteiten.

Hoe het referral programma werkt

Elke JPTC-gebruiker ontvangt een unieke referral code. Wanneer iemand zich via jouw link aanmeldt en een actieve klant wordt, ontvang je 200 euro commissie. Bovendien is er een bonusstructuur: voor elke vijf doorverwezen klanten ontvang je een extra bonus bovenop de standaardcommissie.

De tracking is volledig transparant. In het admin dashboard zie je:

• Totaal aantal referrals -- hoeveel mensen zich via jouw link hebben aangemeld
• Actieve klanten -- hoeveel daarvan daadwerkelijk actief traden
• Opgebouwde commissies -- je totale verdiensten, inclusief bonussen
• Uitbetalingshistorie -- overzicht van alle eerdere uitbetalingen
• Conversieratio -- percentage van klikken dat resulteert in een actieve klant

// Referral registratie bij nieuwe aanmelding
export async function processReferral(newUserId, referralCode) {
  // Zoek de affiliate bij de referral code
  const { data: affiliate } = await supabase
    .from('users')
    .select('id, referral_count')
    .eq('referral_code', referralCode)
    .single();

  if (!affiliate) return;

  const newCount = affiliate.referral_count + 1;
  const baseCommission = 200; // EUR per referral
  const bonusThreshold = 5;

  // Bereken bonus bij elke 5e klant
  const hasBonus = newCount % bonusThreshold === 0;
  const totalPayout = hasBonus
    ? baseCommission + 250 // Extra bonus
    : baseCommission;

  // Registreer de commissie
  await supabase.from('commissions').insert({
    affiliate_id: affiliate.id,
    referred_user_id: newUserId,
    amount: totalPayout,
    has_bonus: hasBonus,
    status: 'pending'
  });

  // Update referral teller
  await supabase
    .from('users')
    .update({ referral_count: newCount })
    .eq('id', affiliate.id);
}

Affiliate marketing strategieen

Het JPTC affiliate programma is bijzonder geschikt voor traders die al een publiek hebben -- via YouTube, een Telegram-groep, of een tradingforum. Omdat je zelf het platform gebruikt en resultaten kunt tonen vanuit je eigen dashboard, is de conversie aanzienlijk hoger dan bij generieke affiliate links.

Effectieve strategieen die JPTC-affiliates gebruiken:

• Live trading streams -- laat zien hoe het systeem trades kopieert terwijl je streamt
• Resultaten delen -- het dashboard exporteert performance-rapporten die je direct kunt posten
• Discord community -- bouw een eigen tradinggroep en verwijs leden door naar JPTC
• Blog content -- schrijf over je ervaring met prop firm challenges en link naar het platform

Veiligheid & compliance: tokens, accounts en data

Een trading bot die verbonden is met prop firm accounts waar tienduizenden euro's op staan vereist serieuze beveiliging. Bij JPTC is security geen nagedachte -- het is verweven in elke laag van de architectuur.

Authenticatie en autorisatie

JPTC gebruikt Supabase Auth voor gebruikersauthenticatie. Dit ondersteunt e-mail/wachtwoord login, magic links en social OAuth providers. Elke API-aanroep vereist een geldig JWT-token dat standaard na 1 uur verloopt. Refresh tokens worden veilig opgeslagen en automatisch vernieuwd door de client SDK.

Op databaseniveau zijn Row Level Security (RLS) policies actief. Dit betekent dat een gebruiker uitsluitend toegang heeft tot zijn eigen accounts, trades en commissie-data. Zelfs als een API-token gecompromitteerd zou worden, kan er geen data van andere gebruikers worden ingezien.

Broker credentials

API-sleutels voor broker-connecties worden versleuteld opgeslagen. De JPTC applicatiecode heeft alleen toegang tot credentials via server-side functies die draaien op Vercel -- er worden nooit credentials naar de client-side gestuurd. Elke broker-connectie wordt bij aanmaak gevalideerd met een read-only test om te verifieren dat de credentials werken zonder een daadwerkelijke trade te plaatsen.

Infrastructuur beveiliging

• SSL/TLS encryptie -- alle communicatie tussen client, API en broker verloopt via HTTPS
• Vercel deployment -- automatische SSL-certificaten, DDoS-bescherming en edge caching
• Supabase -- PostgreSQL met encryptie at-rest, dagelijkse backups en point-in-time recovery
• Environment variables -- alle geheime sleutels worden beheerd via Vercel en Supabase environment variabelen, nooit hardcoded in broncode
• Rate limiting -- API-endpoints zijn beveiligd tegen brute-force aanvallen met progressieve throttling

Compliance overwegingen

JPTC slaat minimale persoonsgegevens op: e-mailadres en naam. Betalingsgegevens worden afgehandeld door externe payment processors -- het platform bewaart zelf geen creditcardnummers of bankgegevens. De applicatie voldoet aan de AVG-vereisten voor dataverwerking, met ingebouwde mogelijkheid tot data-export en accountverwijdering op verzoek.

Stap-voor-stap: JPTC deployen

Of je nu JPTC als trader wilt gebruiken of als developer de technische setup wilt begrijpen, hier volgt het volledige deployment-proces van begin tot eind.

Vereisten

• Node.js 18+ geinstalleerd
• Een Supabase account (gratis tier volstaat voor starten)
• Een Vercel account voor hosting
• Een Discord account met een server waarop je een bot kunt toevoegen
• MetaTrader 4 of 5 met een actief brokeraccount

Deployment stappen

1. Supabase project opzetten

   Maak een nieuw Supabase project aan. Noteer de SUPABASE_URL en SUPABASE_ANON_KEY uit de project settings. Voer de database migratie uit om de tabellen voor trade_signals, users, commissions en accounts aan te maken.

2. Discord bot registreren

   Ga naar het Discord Developer Portal en maak een nieuwe Application aan. Genereer een bot token en nodig de bot uit op je Discord server met de juiste permissions (Send Messages, Embed Links). Bewaar de DISCORD_BOT_TOKEN en het DISCORD_CHANNEL_ID.

3. Repository clonen en configureren

   Clone het JPTC project en installeer de dependencies. Het project gebruikt React + Vite voor de frontend en serverless functies voor de backend.

# Clone en installeer
git clone https://github.com/jptradingcapital/jptc-v3-premium.git
cd jptc-v3-premium
npm install

# Kopieer environment template
cp .env.example .env.local

# Vul de variabelen in
# VITE_SUPABASE_URL=https://xxx.supabase.co
# VITE_SUPABASE_ANON_KEY=eyJ...
# DISCORD_BOT_TOKEN=MTI...
# DISCORD_CHANNEL_ID=1234567890

# Start lokale development server
npm run dev

4. Vercel deployment

   Koppel je GitHub repository aan Vercel. Stel alle environment variables in via het Vercel dashboard (Settings > Environment Variables). Bij elke push naar de main branch wordt automatisch een nieuwe versie gedeployed met zero-downtime.

5. MQL5 Expert Advisor installeren

   Kopieer het bestand JPTCBridge.mq5 naar je MetaTrader data directory onder MQL5/Experts/. Compileer het EA in de MetaEditor. Sleep het EA op de chart van het valutapaar dat je wilt monitoren. Vul je API-token in bij de EA-parameters.

6. Trade copier configureren

   Log in op het JPTC dashboard, navigeer naar Account Management en voeg je prop firm accounts toe. Stel per account de risicoparameters in en activeer de copier. Test eerst met een klein signaal om de verbinding te verifieren.

7. Monitoring activeren

   Het dashboard toont real-time data zodra het systeem draait. Controleer de Discord channel op inkomende signalen en verifieer dat trades correct worden gekopieerd. Stel notificatie-drempels in voor drawdown-waarschuwingen en dagelijkse performance samenvattingen.

Capacitor mobiele app (optioneel)

JPTC ondersteunt ook een mobiele app via Capacitor. Dit is dezelfde React-applicatie die wordt verpakt als native Android (en iOS) app. Hiermee kun je je trades en account-performance monitoren vanaf je telefoon. De build is eenvoudig:

# Capacitor build voor Android
npm run build
npx cap sync android
npx cap open android  # Opent Android Studio

E-mail notificaties via Resend

JPTC gebruikt Resend als e-mailprovider voor transactionele mails: welkomstberichten bij aanmelding, dagelijkse performance-rapporten, drawdown-waarschuwingen en referral-notificaties. De integratie verloopt via de Resend API die wordt aangeroepen vanuit Supabase Edge Functions.