Admirals — โบรกเกอร์ Forex CFD

Admirals คืออะไรและเหมาะกับนักลงทุนแบบไหน

Admirals (เดิมชื่อ Admiral Markets) เป็นโบรกเกอร์ออนไลน์ที่ให้บริการเทรด Forex, CFDs, หุ้น, ETFs, สินค้าโภคภัณฑ์และ Cryptocurrency ก่อตั้งในปี 2001 ที่ประเทศเอสโตเนีย ได้รับ license จากหลายหน่วยงานกำกับดูแลรวมถึง FCA (UK), CySEC (Cyprus), ASIC (Australia) และ EFSA (Estonia)

Admirals มีบัญชีหลายประเภทได้แก่ Trade.MT5 สำหรับเทรด Forex และ CFDs บน MetaTrader 5 มี spread เริ่มต้น 0.5 pips, Invest.MT5 สำหรับลงทุนหุ้นและ ETFs จริงโดยไม่ใช่ CFD ค่าคอมมิชชั่นเริ่มต้น $0.02 ต่อหุ้น และ Zero.MT5 สำหรับนักเทรดมืออาชีพที่ต้องการ raw spread เริ่มต้น 0.0 pips พร้อมค่าคอมมิชชั่น

จุดเด่นของ Admirals คือ เครื่องมือวิเคราะห์ที่ครบครัน มี MetaTrader Supreme Edition ที่เพิ่ม indicators และเครื่องมือพิเศษให้ฟรี มีโปรแกรมการศึกษาและ webinar สำหรับผู้เริ่มต้น ระบบ copy trading สำหรับ copy กลยุทธ์จากนักเทรดมืออาชีพ และ API สำหรับ algorithmic trading

เหมาะสำหรับนักลงทุนที่ต้องการโบรกเกอร์ที่มี regulation จากหลายประเทศ ต้องการเทรดได้หลายตลาดในบัญชีเดียว และต้องการเครื่องมือวิเคราะห์ที่ครบถ้วนบน MetaTrader platform

เนื้อหาเกี่ยวข้อง — บทความที่เกี่ยวข้อง: Crowdsec IPS Platform Engineering

เปิดบัญชี Admirals และตั้งค่าแพลตฟอร์ม

ขั้นตอนการเปิดบัญชีและเตรียมพร้อมสำหรับการเทรด

# ขั้นตอนเปิดบัญชี Admirals

#

# 1. สมัครที่ https://admirals.com

#    - กรอกข้อมูลส่วนตัว (ชื่อ, email, เบอร์โทร)

#    - เลือกประเภทบัญชี (Trade.MT5, Invest.MT5, Zero.MT5)

#

# 2. ยืนยันตัวตน (KYC)

#    - อัพโหลดบัตรประชาชน/พาสปอร์ต

#    - อัพโหลดหลักฐานที่อยู่ (ใบแจ้งหนี้สาธารณูปโภค)

#    - รอ 1-2 วันทำการ

#

# 3. ฝากเงิน

#    - Bank Transfer (ฟรี, 1-3 วัน)

#    - Credit/Debit Card (ทันที)

#    - Skrill/Neteller (ทันที)

#    - ขั้นต่ำ: $100 สำหรับ Trade.MT5, $1 สำหรับ Invest.MT5



# ดาวน์โหลด MetaTrader 5

# Windows: https://download.mql5.com/cdn/web/metaquotes.software.corp/mt5/mt5setup.exe

# macOS: ดาวน์โหลดจาก App Store หรือใช้ web terminal

# Linux: ใช้ Wine หรือ web terminal



# ติดตั้ง MetaTrader 5 บน Linux ด้วย Wine

sudo dpkg --add-architecture i386

sudo apt update

sudo apt install wine64 wine32 -y

wine mt5setup.exe



# หรือใช้ Docker

docker run -d --name mt5 \

  -e DISPLAY=$DISPLAY \

  -v /tmp/.X11-unix:/tmp/.X11-unix \

  -v $HOME/mt5:/root/.wine/drive_c/Program\ Files/MetaTrader\ 5 \

  scottyhardy/docker-wine \

  wine "/root/.wine/drive_c/Program Files/MetaTrader 5/terminal64.exe"



# ตั้งค่า connection

# Server: AdmiralsGroup-Live (สำหรับบัญชีจริง)

# Server: AdmiralsGroup-Demo (สำหรับบัญชีทดลอง)

# Login: หมายเลขบัญชีที่ได้รับทาง email

# Password: รหัสผ่านที่ตั้งไว้

ตั้งค่า MetaTrader 5 สำหรับเทรดกับ Admirals

ตั้งค่า MetaTrader 5 ให้เหมาะสำหรับการเทรดจริง

แนะนำเพิ่มเติม — หนังสือเทรดที่ SiamCafeBook

# ติดตั้ง MetaTrader 5 Python Package

pip install MetaTrader5 pandas numpy matplotlib



# เชื่อมต่อ MT5 จาก Python

import MetaTrader5 as mt5

import pandas as pd

from datetime import datetime



# เริ่มต้น MT5

if not mt5.initialize():

    print(f"MT5 initialize failed: {mt5.last_error()}")

    quit()



# ล็อกอินเข้าบัญชี

account = 12345678  # หมายเลขบัญชี

password = "your_password"

server = "AdmiralsGroup-Live"



if mt5.login(account, password=password, server=server):

    info = mt5.account_info()

    print(f"Account: {info.login}")

    print(f"Balance: ")

    print(f"Equity: ")

    print(f"Margin: ")

    print(f"Free Margin: ")

    print(f"Leverage: 1:{info.leverage}")

else:

    print(f"Login failed: {mt5.last_error()}")



# ดูข้อมูล symbol

symbol_info = mt5.symbol_info("EURUSD")

if symbol_info:

    print(f"\nEURUSD Info:")

    print(f"  Bid: {symbol_info.bid}")

    print(f"  Ask: {symbol_info.ask}")

    print(f"  Spread: {symbol_info.spread} points")

    print(f"  Min Lot: {symbol_info.volume_min}")

    print(f"  Max Lot: {symbol_info.volume_max}")



# ดึงข้อมูลราคาย้อนหลัง

rates = mt5.copy_rates_from_pos("EURUSD", mt5.TIMEFRAME_H1, 0, 100)

df = pd.DataFrame(rates)

df["time"] = pd.to_datetime(df["time"], unit="s")

print(f"\nLatest 5 candles:")

print(df[["time", "open", "high", "low", "close", "tick_volume"]].tail())



mt5.shutdown()

ใช้ Admirals API สำหรับ Automated Trading

สร้างระบบเทรดอัตโนมัติผ่าน MetaTrader 5 Python API

#!/usr/bin/env python3

# admirals_trader.py — Automated Trading System สำหรับ Admirals

import MetaTrader5 as mt5

import pandas as pd

import numpy as np

from datetime import datetime

import time



class AdmiralsTrader:

    def __init__(self, account, password, server="AdmiralsGroup-Demo"):

        self.account = account

        self.password = password

        self.server = server

        self.connected = False



    def connect(self):

        if not mt5.initialize():

            raise ConnectionError(f"MT5 init failed: {mt5.last_error()}")

        if not mt5.login(self.account, password=self.password, server=self.server):

            raise ConnectionError(f"Login failed: {mt5.last_error()}")

        self.connected = True

        info = mt5.account_info()

        print(f"Connected: Account {info.login}, Balance: ")



    def get_data(self, symbol, timeframe, bars=200):

        rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, bars)

        df = pd.DataFrame(rates)

        df["time"] = pd.to_datetime(df["time"], unit="s")

        df.set_index("time", inplace=True)

        return df



    def calculate_signals(self, df):

        df["ema_fast"] = df["close"].ewm(span=12).mean()

        df["ema_slow"] = df["close"].ewm(span=26).mean()

        df["macd"] = df["ema_fast"] - df["ema_slow"]

        df["signal"] = df["macd"].ewm(span=9).mean()



        delta = df["close"].diff()

        gain = delta.where(delta > 0, 0).rolling(14).mean()

        loss = (-delta).where(delta < 0, 0).rolling(14).mean()

        df["rsi"] = 100 - (100 / (1 + gain / loss))



        latest = df.iloc[-1]

        prev = df.iloc[-2]



        if (latest["macd"] > latest["signal"] and

            prev["macd"] <= prev["signal"] and

            latest["rsi"] < 70):

            return "BUY"

        elif (latest["macd"] < latest["signal"] and

              prev["macd"] >= prev["signal"] and

              latest["rsi"] > 30):

            return "SELL"

        return "HOLD"



    def place_order(self, symbol, order_type, lot=0.01, sl_pips=50, tp_pips=100):

        info = mt5.symbol_info(symbol)

        if not info:

            print(f"Symbol {symbol} not found")

            return None



        point = info.point

        price = info.ask if order_type == "BUY" else info.bid

        sl = price - sl_pips * point if order_type == "BUY" else price + sl_pips * point

        tp = price + tp_pips * point if order_type == "BUY" else price - tp_pips * point



        request = {

            "action": mt5.TRADE_ACTION_DEAL,

            "symbol": symbol,

            "volume": lot,

            "type": mt5.ORDER_TYPE_BUY if order_type == "BUY" else mt5.ORDER_TYPE_SELL,

            "price": price,

            "sl": round(sl, info.digits),

            "tp": round(tp, info.digits),

            "deviation": 10,

            "magic": 234000,

            "comment": "admirals_bot",

            "type_time": mt5.ORDER_TIME_GTC,

            "type_filling": mt5.ORDER_FILLING_IOC,

        }



        result = mt5.order_send(request)

        if result.retcode == mt5.TRADE_RETCODE_DONE:

            print(f"Order placed: {order_type} {lot} {symbol} @ {price}")

            return result

        else:

            print(f"Order failed: {result.retcode} - {result.comment}")

            return None



    def get_positions(self):

        positions = mt5.positions_get()

        if positions:

            for p in positions:

                profit_str = f"+" if p.profit >= 0 else f"-"

                print(f"  {p.symbol} {'BUY' if p.type==0 else 'SELL'} "

                      f"{p.volume} lots @ {p.price_open} P/L: {profit_str}")

        return positions



    def close_position(self, ticket):

        position = mt5.positions_get(ticket=ticket)

        if not position:

            return False

        pos = position[0]

        close_type = mt5.ORDER_TYPE_SELL if pos.type == 0 else mt5.ORDER_TYPE_BUY

        price = mt5.symbol_info_tick(pos.symbol).bid if pos.type == 0 else mt5.symbol_info_tick(pos.symbol).ask



        request = {

            "action": mt5.TRADE_ACTION_DEAL,

            "symbol": pos.symbol,

            "volume": pos.volume,

            "type": close_type,

            "position": ticket,

            "price": price,

            "deviation": 10,

            "magic": 234000,

            "comment": "close_bot",

            "type_time": mt5.ORDER_TIME_GTC,

            "type_filling": mt5.ORDER_FILLING_IOC,

        }

        result = mt5.order_send(request)

        return result.retcode == mt5.TRADE_RETCODE_DONE



    def disconnect(self):

        mt5.shutdown()

        self.connected = False

กลยุทธ์การเทรดและ Risk Management

ตั้งค่า Risk Management ที่เหมาะสมสำหรับการเทรดกับ Admirals

เนื้อหาเกี่ยวข้อง — ทำความเข้าใจ python interpreter คือ — คู่มือฉบับสมบูรณ์ 2026

#!/usr/bin/env python3

# risk_manager.py — Risk Management สำหรับ Admirals Trading

import MetaTrader5 as mt5



class RiskManager:

    def __init__(self, max_risk_pct=1.0, max_daily_loss_pct=3.0, max_positions=5):

        self.max_risk_pct = max_risk_pct

        self.max_daily_loss_pct = max_daily_loss_pct

        self.max_positions = max_positions



    def calculate_lot_size(self, symbol, sl_pips, risk_pct=None):

        if risk_pct is None:

            risk_pct = self.max_risk_pct



        account = mt5.account_info()

        risk_amount = account.balance * (risk_pct / 100)



        sym_info = mt5.symbol_info(symbol)

        point = sym_info.point

        tick_value = sym_info.trade_tick_value



        if tick_value == 0 or sl_pips == 0:

            return sym_info.volume_min



        lot = risk_amount / (sl_pips * tick_value / point)

        lot = max(sym_info.volume_min, min(lot, sym_info.volume_max))

        lot = round(lot, 2)



        return lot



    def check_daily_loss(self):

        account = mt5.account_info()

        daily_pnl = account.equity - account.balance

        max_loss = account.balance * (self.max_daily_loss_pct / 100)



        if daily_pnl < -max_loss:

            print(f"DAILY LOSS LIMIT: P/L=, Limit=")

            return False

        return True



    def check_max_positions(self):

        positions = mt5.positions_total()

        if positions >= self.max_positions:

            print(f"MAX POSITIONS: {positions}/{self.max_positions}")

            return False

        return True



    def can_trade(self):

        if not self.check_daily_loss():

            return False

        if not self.check_max_positions():

            return False

        return True



    def print_status(self):

        account = mt5.account_info()

        positions = mt5.positions_total()

        daily_pnl = account.equity - account.balance

        max_loss = account.balance * (self.max_daily_loss_pct / 100)



        print(f"\n=== Risk Status ===")

        print(f"Balance: ")

        print(f"Equity: ")

        print(f"Daily P/L:  (limit: )")

        print(f"Positions: {positions}/{self.max_positions}")

        print(f"Margin Used: ")

        print(f"Free Margin: ")

        print(f"Margin Level: {account.margin_level:.1f}%")

        print(f"Can Trade: {'YES' if self.can_trade() else 'NO'}")

สร้าง Trading Bot ด้วย Python และ MT5

สร้าง trading bot ที่ทำงานอัตโนมัติตาม strategy ที่กำหนด

#!/usr/bin/env python3

# trading_bot.py — Automated Trading Bot

import MetaTrader5 as mt5

import time

import logging

from datetime import datetime



logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")

log = logging.getLogger("bot")



CONFIG = {

    "symbol": "EURUSD",

    "timeframe": mt5.TIMEFRAME_H1,

    "lot": 0.01,

    "sl_pips": 30,

    "tp_pips": 60,

    "check_interval": 60,  # วินาที

    "max_positions": 3,

    "max_daily_loss": 50.0,  # USD

}



def run_bot(trader, risk_mgr):

    symbol = CONFIG["symbol"]

    log.info(f"Bot started: {symbol} on {CONFIG['timeframe']}")



    while True:

        try:

            if not risk_mgr.can_trade():

                log.warning("Trading paused: risk limits reached")

                time.sleep(CONFIG["check_interval"] * 5)

                continue



            # ดึงข้อมูลราคา

            df = trader.get_data(symbol, CONFIG["timeframe"], 200)

            if df is None or len(df) < 50:

                log.warning("Insufficient data")

                time.sleep(CONFIG["check_interval"])

                continue



            # คำนวณสัญญาณ

            signal = trader.calculate_signals(df)



            # ตรวจสอบว่ามี position เปิดอยู่หรือไม่

            positions = mt5.positions_get(symbol=symbol)

            has_position = len(positions) > 0 if positions else False



            if signal in ["BUY", "SELL"] and not has_position:

                lot = risk_mgr.calculate_lot_size(

                    symbol, CONFIG["sl_pips"]

                )

                result = trader.place_order(

                    symbol, signal, lot,

                    CONFIG["sl_pips"], CONFIG["tp_pips"]

                )

                if result:

                    log.info(f"Signal: {signal} | Lot: {lot}")



            # แสดงสถานะ

            now = datetime.now()

            if now.minute == 0 and now.second < CONFIG["check_interval"]:

                risk_mgr.print_status()



        except Exception as e:

            log.error(f"Error: {e}")



        time.sleep(CONFIG["check_interval"])



# if __name__ == "__main__":

#     trader = AdmiralsTrader(12345678, "password", "AdmiralsGroup-Demo")

#     trader.connect()

#     risk_mgr = RiskManager(max_risk_pct=1.0, max_daily_loss_pct=3.0)

#     run_bot(trader, risk_mgr)

FAQ คำถามที่พบบ่อย

Q: Admirals ปลอดภัยไหม?

A: Admirals ได้รับ license จากหน่วยงานกำกับดูแลหลายแห่งรวมถึง FCA ของอังกฤษ CySEC ของไซปรัส และ ASIC ของออสเตรเลีย เงินฝากของลูกค้าแยกเก็บในบัญชี segregated accounts มีระบบ Negative Balance Protection ที่ป้องกันไม่ให้ขาดทุนเกินเงินฝาก และมีการประกันเงินฝากสูงสุด 20,000 EUR ภายใต้กองทุนชดเชย

แนะนำเพิ่มเติม — ระบบเทรดของ iCafeForex

Q: Spread ของ Admirals เท่าไหร่?

เนื้อหาเกี่ยวข้อง — ทำความเข้าใจ position sizing คํานวณ

A: ขึ้นอยู่กับประเภทบัญชี Trade.MT5 มี spread เริ่มต้น 0.5 pips สำหรับ EURUSD (ไม่มีค่าคอมมิชชั่น) Zero.MT5 มี spread เริ่มต้น 0.0 pips แต่มีค่าคอมมิชชั่น $3 ต่อ lot ต่อฝั่ง สำหรับ day traders ที่เทรดบ่อย Zero.MT5 อาจคุ้มกว่าเพราะ total cost ต่ำกว่า

Q: Admirals รองรับ EA (Expert Advisor) ไหม?

A: รองรับทั้ง Expert Advisor บน MetaTrader 4/5 และ Python API ผ่าน MetaTrader5 library สามารถรัน automated trading strategies ได้ทั้งบน VPS และเครื่องส่วนตัว Admirals ยังมี MetaTrader Supreme Edition ที่เพิ่ม indicators และเครื่องมือพิเศษให้ฟรีอีกด้วย

Q: Leverage สูงสุดของ Admirals เท่าไหร่?

เนื้อหาเกี่ยวข้อง — SvelteKit Form Actions DevOps Culture

A: ขึ้นอยู่กับ regulation ของแต่ละภูมิภาค ลูกค้าภายใต้ FCA/CySEC ได้ leverage สูงสุด 1:30 สำหรับ major forex pairs (ตาม ESMA regulation) ลูกค้าภายใต้ regulation อื่นอาจได้สูงสุด 1:500 สำหรับผู้เริ่มต้นแนะนำใช้ leverage ไม่เกิน 1:10 เพื่อลดความเสี่ยง

Q: ถอนเงินจาก Admirals ใช้เวลากี่วัน?

A: Bank Transfer ใช้เวลา 1-3 วันทำการ Credit/Debit Card ใช้เวลา 1-5 วันทำการ E-wallets เช่น Skrill Neteller ภายใน 24 ชั่วโมง Admirals ไม่คิดค่าธรรมเนียมสำหรับการถอนเงินครั้งแรกของแต่ละเดือน ครั้งต่อไปอาจมีค่าธรรมเนียมเล็กน้อย