איך לבנות בוט לקריפטו (מדריך שלב אחר שלב ל-2026)

עודכן לאחרונה: אפריל 2026

*כתב ויתור: המאמר הזה הוא לצורכי מידע בלבד ואינו מהווה ייעוץ פיננסי. מסחר בקריפטו כרוך בסיכון משמעותי של הפסד. לעולם אל תסחרו עם כסף שאתם לא יכולים להרשות לעצמכם להפסיד. תמיד עשו מחקר עצמאי (DYOR).*

את הבוט הראשון שלי בניתי ב-2023. 180 שורות של Python מבולגנות, על VPS של 4 דולר לחודש, שהפסיד כסף שני חודשים ברצף. בחודש השלישי כתבתי מחדש את מודול ניהול הסיכונים, תיקנתי באג של rate-limiting שהיה שורף אותי בכל שלישית הזמנות, ולבסוף הגעתי לאיזון. בחודש הרביעי הוא כבר הרוויח. לא רווחים שמשנים את החיים, אבל בכל זאת.

אם אתם מפתחים שמסתכלים על שירותי הבוט המוכנים שגובים 50-100 דולר בחודש, אני רוצה לשכנע אתכם לבנות בעצמכם. זה לא כל כך קשה. לא צריך תואר במדעי המחשב. לא צריך להיות קוואנט. צריך Python, חשבון testnet, בערך שני סופי שבוע, ונכונות לאבד קצת כסף "בירה" בזמן הדיבאג.

המדריך הזה עובר על כל מה שהייתי רוצה שמישהו יגיד לי כשהתחלתי: הסטאק, הגדרת ה-API, בוט DCA עובד אמיתי, אסטרטגיית ממוצע נע, backtesting, ניהול סיכונים, פריסה, וכל הדרכים שראיתי את עצמי ומפתחים אחרים מפוצצים חשבונות. בסוף המדריך יהיה לכם קוד שרץ, לא רק תיאוריה.

למה לבנות ולא לקנות? שלוש סיבות. ראשית, אתם שולטים בלוגיקה. אם לאסטרטגיה שלכם יש יתרון, אתם שומרים על 100% ממנו במקום להאכיל אותו למערכת copy-trading של מישהו אחר. שנית, אין מנוי חודשי. VPS עולה 4 דולר. מנוי 3Commas עולה 50-100 דולר. זה מתחיל לתפוס. שלישית, אתם ממש מבינים מה קורה. בוטים בתיבה שחורה נשברים ואין לכם מושג למה. הבוט שלכם נשבר ואתם יכולים לקרוא את ה-stack trace.

בואו נבנה.

מה צריך לפני שכותבים שורת קוד ראשונה

לפני שנוגעים במקלדת, תסדרו את הדברים האלה. ראיתי יותר מדי מפתחים מדלגים על שלב ראשון ואז תוהים למה הבוט שלהם מקבל "invalid signature" בשלוש לפנות בוקר.

1. חשבון בורסה עם גישת API. אני משתמש ב-Bybit לרוב עבודת הבוט שלי כי תיעוד ה-API שלהם קריא, ה-testnet חינמי ופונקציונלי לגמרי, ומגבלות ה-rate שלהם נדיבות בהשוואה ל-Binance. אפשר לקבל את מפתחות ה-API של Bybit כאן ← — נרשמים, מאמתים, ואז הולכים ל-Account > API Management. יוצרים מפתח testnet קודם כל, לא mainnet. תמיד testnet קודם.

2. גישה ל-testnet. לרוב הבורסות יש סביבת testnet נפרדת עם כסף מזויף ו-API endpoint נפרד. ה-testnet של Bybit נמצא ב-`api-testnet.bybit.com`. ל-Binance יש `testnet.binance.vision`. השתמשו בהם 3-4 שבועות ראשונים של פיתוח. תעשו באגים שמכניסים הזמנות של 1000 פעמים הגודל המתוכנן. תשאלו אותי מאיפה אני יודע.

3. מודל מנטלי ברור של מה הבוט עושה. כתבו אותו בעברית לפני שכותבים בקוד. משהו כמו: "כל 4 שעות, בדוק את מחיר BTC/USDT. אם יש לי פחות מ-500 דולר ב-BTC, קנה עוד 50 דולר. אם BTC ירד יותר מ-5% מהכניסה הממוצעת שלי, עצור קנייה ל-24 שעות." זה מפרט אסטרטגיה. קוד הוא רק תרגום.

4. תקציב לשלב הלמידה. אני ממליץ על 200-500 דולר של כסף אמיתי אחרי שסיימתם עם testnet. מספיק קטן שלא תבכו אם ייעלם, מספיק גדול שהעמלות לא יאכלו אתכם חיים (עמלות על הזמנות של 20 דולר הן אחוז מטריף).

5. Python בסיסי. צריך לדעת פונקציות, מחלקות, dicts, try/except, ואיך לקרוא stack trace. לא צריך לדעת asyncio, type hints, או design patterns. אלה מגיעים אחר כך.

6. קובץ טקסט רגיל למפתחות ה-API. אף פעם אל תשרינו מפתחות ישירות בסקריפט. השתמשו בקובץ `.env` וטענו אותו עם `python-dotenv`. אם תעלו מפתח API ל-GitHub, בוטים ינקזו את החשבון שלכם תוך פחות מ-60 שניות. זה קרה לי. הפסדתי 340 דולר תוך 45 שניות לבוט מגרד GitHub. השתמשו ב-`.gitignore`. תמיד.

ברגע שיש לכם את כל ששת הסעיפים, אתם מוכנים להתחיל לכתוב קוד.

Free: Crypto Trading Platform Cheat Sheet

Side-by-side fee comparison, ratings, and quick-pick recommendations for every major exchange and trading bot. Save hours of research.

No spam. Instant download on the next page.

בחרו שפה ו-Framework

תשעה מתוך עשרה בוטי מסחר קמעונאיים כתובים ב-Python, ולסיבה טובה: האקוסיסטם בשל, הספריות מצוינות, ואפשר ללכת מ"קובץ ריק" ל"בוט שמציב הזמנות" בכ-50 שורות. אבל Python אינה האפשרות היחידה, ותלוי במטרות שלכם, שפה אחרת עשויה לשרת אתכם טוב יותר.

הנה איך האפשרויות העיקריות נראות בפועל:

שפה / Framework	הכי מתאים ל	מהירות	אקוסיסטם	עקומת למידה	הערות
Python + ccxt	95% מהבוטים הקמעונאיים	איטית (ms)	מצוין	קל	ברירת המחדל. השתמשו בזה אלא אם יש לכם סיבה ספציפית לא לעשות זאת.
Python + freqtrade	בוטים כבדי-אסטרטגיה DCA/MA	איטית	טוב	בינוני	Framework דעתני, batteries included, מצוין למתחילים שרוצים מבנה.
Node.js + ccxt	בוטים משולבי-ווב	איטית	טוב	קל	השתמשו אם אתם כבר מפתחי JS. מודל הasync נחמד.
Rust + tokio	HFT, רגיש-לזמן-אחזור	מהיר (us)	גדל	קשה	מיותר ל-99% מהקמעונאיים. השתמשו אם אתם עושים market making או arb תת-שנייה.
Go + custom client	שירותי ייצור	מהיר	בינוני	בינוני	טוב לתשתית "always-on" אבל ספריות ספציפיות למסחר פחות.
C++	HFT מוסדי	הכי מהיר	דל	קשה מאד	אל תעשו. ברצינות, אל תעשו, אלא אם אתם עובדים ב-Jane Street.

ההמלצה הכנה שלי למפתח שבונה את הבוט הראשון שלו ב-2026: Python עם ccxt. זהו. אפשר תמיד לשכתב ב-Rust מאוחר יותר אם תמצאו יתרון אמיתי שדורש זאת. 99% מהאסטרטגיות הקמעונאיות אינן רגישות לאחזור — הן רגישות לאסטרטגיה. אסטרטגיה בינונית שכתובה ב-Rust עדיין תפסיד כסף. אסטרטגיה טובה ב-Python עדיין תרוויח.

ccxt היא ספריית API אחודה לבורסות קריפטו שמסכמת 100+ בורסות. במקום ללמוד את ה-REST spec של Bybit, אז של Binance, אז של OKX, לומדים ccxt פעם אחת וכל בורסה נראית אותו הדבר. זו הספריה הבודדת הכי בעלת ערך בפיתוח קריפטו. היא חינמית, קוד פתוח, ומתוחזקת.

freqtrade הוא framework מלא שבנוי מעל ccxt. אם רוצים פיגומים, תבניות אסטרטגיה, backtesting מובנה, ובוט Telegram מהקופסה, השתמשו ב-freqtrade. אם רוצים להבין מה קורה מתחת לכפנת המנוע, התחילו עם ccxt גולמי קודם ועברו ל-freqtrade מאוחר יותר.

במדריך הזה אני משתמש ב-ccxt גולמי. תלמדו יותר.

הגדרת סביבת הפיתוח

פתחו טרמינל. אני מניח macOS או Linux. ב-Windows, השתמשו ב-WSL2 — תאמינו לי, זה יחסוך לכם כאב ראש.

```bash

mkdir my-trading-bot

cd my-trading-bot

python3 -m venv venv

source venv/bin/activate # on Windows: venv\Scripts\activate

pip install ccxt python-dotenv pandas

```

זה נותן לכם virtual environment נקי עם ccxt (API לבורסה), python-dotenv (טוען את מפתחות ה-API מקובץ), ו-pandas (לעבודה עם נתוני נרות). זמן התקנה: כ-30 שניות.

עכשיו צרו קובץ `.env` באותה תיקייה:

```

BYBIT_API_KEY=your_testnet_key_here

BYBIT_API_SECRET=your_testnet_secret_here

```

וגם `.gitignore`:

```

.env

venv/

__pycache__/

*.pyc

```

זהו שלב אפס, והסיבה מספר אחת שאני רואה מפתחים ניזוקים. קובץ ה-`.env` מחזיק את המפתחות שלכם. ה-`.gitignore` מוודא שאף פעם לא תעלו אותו. עשו את שניהם. בכל פעם.

עכשיו בדקו את החיבור שלכם. צרו קובץ בשם `connection_test.py`:

```python

import os

import ccxt

from dotenv import load_dotenv

load_dotenv()

exchange = ccxt.bybit({

'apiKey': os.getenv('BYBIT_API_KEY'),

'secret': os.getenv('BYBIT_API_SECRET'),

'options': {'defaultType': 'spot'},

})

exchange.set_sandbox_mode(True)

balance = exchange.fetch_balance()

print("Testnet USDT balance:", balance['total'].get('USDT', 0))

ticker = exchange.fetch_ticker('BTC/USDT')

print(f"BTC/USDT last price: ${ticker['last']}")

```

הריצו: `python connection_test.py`. אם רואים יתרה ומחיר BTC, אתם מחוברים. אם רואים שגיאת auth, המפתחות שלכם שגויים או שכחתם את `set_sandbox_mode(True)`. אם רואים שגיאת רשת, בדקו את האינטרנט.

עוד דבר: ל-testnet של Bybit יש כפתור "request testnet funds" בממשק הווב שלהם. לחצו עליו. תנו לעצמכם 10,000 USDT של כסף מזויף. עכשיו אפשר ממש לבצע הזמנות בלי לסכן הון אמיתי.

הבוט הראשון שלכם: דוגמת DCA עובדת ב-Python

Dollar-cost averaging הוא ה-"Hello World" של בוטי מסחר. הלוגיקה פשוטה: קנה סכום דולרי קבוע של נכס בלוח זמנים קבוע, ללא קשר למחיר. היסטורית, DCA לתוך BTC הניב ביצועים טובים יותר מרוב אסטרטגיות המסחר הפעיל שנצפו באותה תקופה, בעיקר מפני שהוא מסיר רגש ואינו דורש לנבא דבר.

הנה בוט DCA מינימלי אבל עובד ממש ב-40 שורות:

```python

import os

import time

import ccxt

from dotenv import load_dotenv

load_dotenv()

exchange = ccxt.bybit({

'apiKey': os.getenv('BYBIT_API_KEY'),

'secret': os.getenv('BYBIT_API_SECRET'),

'options': {'defaultType': 'spot'},

})

exchange.set_sandbox_mode(True)

SYMBOL = 'BTC/USDT'

BUY_AMOUNT_USD = 50

INTERVAL_SECONDS = 60 * 60 * 4 # every 4 hours

def buy_btc(usd_amount):

try:

ticker = exchange.fetch_ticker(SYMBOL)

price = ticker['last']

btc_amount = round(usd_amount / price, 6)

order = exchange.create_market_buy_order(SYMBOL, btc_amount)

print(f"[BUY] {btc_amount} BTC @ ${price} (spent ~${usd_amount})")

return order

except ccxt.InsufficientFunds:

print("[ERROR] Not enough USDT in account")

except ccxt.NetworkError as e:

print(f"[ERROR] Network issue: {e}")

except Exception as e:

print(f"[ERROR] Unexpected: {e}")

if __name__ == '__main__':

while True:

buy_btc(BUY_AMOUNT_USD)

time.sleep(INTERVAL_SECONDS)

```

זהו. 40 שורות. כל ארבע שעות הבוט הזה קונה BTC בשווי 50 דולר במחיר שוק. הוא מטפל בחוסר כספים, שגיאות רשת, וכל חריגה בלתי צפויה מבלי לקרוס. הוא מדפיס כל קנייה כדי שתוכלו לבדוק את הלוג.

הריצו אותו עם `python dca_bot.py` ותנו לו לשבת יום ב-testnet. תראו קניות מצטברות בהיסטוריית ההזמנות שלכם. בדקו את ממשק ה-testnet של Bybit — תראו את פוזיציית ה-BTC גדלה.

מה חסר? הרבה. אין persistence (איתחול מחדש ואתם מאבדים מצב), אין הגנה מפני drawdown, אין position sizing, אין circuit breaker, אין לוגינג לקובץ. נוסיף אלה. אבל זה השלד שכל בוט DCA מתחיל ממנו. הבינו אותו לחלוטין לפני שמוסיפים מורכבות.

הוספת אסטרטגיה: Moving Average Crossover

DCA הוא פסיבי. אסטרטגיה אמיתית מגיבה לתנאי השוק. האסטרטגיה הפשוטה ביותר מבוססת-כללים היא moving average crossover: כאשר MA מהיר חוצה מעל MA איטי, זה סיגנל שורי; כאשר הוא חוצה מתחת, דובי.

זה לא נוסחת קסם — MA crossovers ידועים מאז שנות ה-50 ולא מדפיסים כסף חופשי — אבל זו אסטרטגיית הוראה מצוינת כי הלוגיקה ברורה ואפשר ממש לראות למה היא קונה ומוכרת.

```python

import ccxt

import pandas as pd

exchange = ccxt.bybit({'options': {'defaultType': 'spot'}})

exchange.set_sandbox_mode(True)

def get_signal(symbol='BTC/USDT', timeframe='1h', fast=20, slow=50):

ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=100)

df = pd.DataFrame(ohlcv, columns=['ts','open','high','low','close','vol'])

df['fast_ma'] = df['close'].rolling(fast).mean()

df['slow_ma'] = df['close'].rolling(slow).mean()

last = df.iloc[-1]

prev = df.iloc[-2]

if prev['fast_ma'] <= prev['slow_ma'] and last['fast_ma'] > last['slow_ma']:

return 'BUY'

if prev['fast_ma'] >= prev['slow_ma'] and last['fast_ma'] < last['slow_ma']:

return 'SELL'

return 'HOLD'

if __name__ == '__main__':

print(f"Current signal: {get_signal()}")

```

הפונקציה הזו מושכת 100 נרות שעתיים אחרונים, מחשבת ממוצע נע פשוט של 20 תקופות ו-50 תקופות, ואז בודקת אם ה-MA המהיר חצה מעל ה-MA האיטי בנר האחרון שהסתיים (סיגנל קנייה) או חצה מתחת (מכירה). כל השאר הוא HOLD.

להפוך את זה לבוט מסחר מלא, עטפו אותו בלולאה, הוסיפו מעקב פוזיציות (האם אתם כרגע בעסקה?), וחברו אותו לקריאות `create_market_buy_order` / `create_market_sell_order` מדוגמת ה-DCA. הייתי מציע לכתוב את הלולאה הזו בעצמכם כתרגיל — אם אתם לא יכולים לעשות את זה, אתם לא מבינים את הקוד מספיק טוב כדי לסמוך עליו עם כסף אמיתי.

אזהרה כנה: ל-MA crossovers יש ביצועים גרועים בשווקים לאופקיים. הם מבלבלים אתכם — קנה, מכור, קנה, מכור — וכל סיבוב עולה עמלות. בשוק מגמתי הם סבירים. בטווח גלי הם ישחקו את החשבון שלכם. לכן אנשי המקצוע מוסיפים פילטרי משטר (לסחור ב-MA crossovers רק כאשר ADX > 25, למשל). התחילו פשוט, מדדו את הנזק, ואז הוסיפו מורכבות.

Backtesting לפני שהולכים חיים

הנה הכלל: לעולם אל תריצו אסטרטגיה עם כסף אמיתי אם לא עשיתם backtesting. אף פעם. לא אכפת לי כמה ברורה הלוגיקה נראית.

Backtesting אומר הרצת האסטרטגיה שלכם מול נתוני מחיר היסטוריים וראיה כיצד היא הייתה מתפקדת. זה לא ערובה לביצועים עתידיים — תוצאות העבר לא מנבאות את העתיד — אבל זה הפילטר הטוב ביותר לרעיונות גרועים. אסטרטגיה שנכשלת ב-backtesting תיכשל גם בחיים. אסטרטגיה שעוברת backtesting *עשויה* להצליח בחיים.

שתי אפשרויות עיקריות:

אפשרות 1: TradingView ← לעיצוב אסטרטגיה ויזואלי. Pine Script של TradingView מאפשר לכם לקודד אסטרטגיה, להריץ אותה על שנים של נתונים היסטוריים, ולקבל עקומת הון תוך 30 שניות. מצוין לאב-טיפוס. אני מעצב כל אסטרטגיה ב-TradingView קודם, מאשר שללוגיקה יש לפחות קצת יתרון, ואז מעביר אותה ל-Python. תוכניות TradingView בתשלום (14.95-59.95 דולר לחודש) שוות את זה אם אתם רציניים — התוכנית החינמית מגבילה את טווח ה-backtesting.

אפשרות 2: ספריות Python כמו Backtrader, vectorbt, או backtester המובנה של freqtrade. אלה מאפשרים לכם לבדוק backtesting בתוך קוד ה-Python שלכם מול אותם נתונים שהבוט החי שלכם ישתמש בהם. vectorbt הוא האהוב עלי — הוא מהיר (משתמש ב-numba), ה-API נקי, ואפשר לבדוק אלפי שילובי פרמטרים תוך דקות.

הנה דוגמת vectorbt מינימלית:

```python

import vectorbt as vbt

price = vbt.YFData.download('BTC-USD', start='2022-01-01').get('Close')

fast_ma = vbt.MA.run(price, 20)

slow_ma = vbt.MA.run(price, 50)

entries = fast_ma.ma_crossed_above(slow_ma)

exits = fast_ma.ma_crossed_below(slow_ma)

pf = vbt.Portfolio.from_signals(price, entries, exits, init_cash=10000, fees=0.001)

print(pf.stats())

```

שבע שורות ויש לכם עקומת הון מלאה, יחס Sharpe, max drawdown, ואחוז ניצחון. הריצו על timeframes וסמלים שונים. אם האסטרטגיה שלכם עושה 8% בשנה עם 30% drawdown על הנייר, היא כנראה תפסיד כסף בחיים אחרי עמלות וslippage. אם היא עושה 40% בשנה עם 15% drawdown על הנייר, *אולי* היא אמיתית. היו ספקניים לגבי כל דבר שנראה טוב מדי — כנראה overfit.

ניהול סיכונים: החלק שרוב המפתחים מדלגים עליו

אני אגיד את זה בפירוש: האסטרטגיה שלכם היא לא מה שגורם לכם להיות רווחיים. ניהול סיכונים הוא מה שגורם לכם להיות רווחיים. ראיתי אסטרטגיות מבריקות מפוצצות חשבונות כי המפתח לא הגביל את גודל הפוזיציה. ראיתי אסטרטגיות טיפשות ששרדו שנים כי המפתח הגדיר stop-loss קשה של 2% לכל עסקה.

ארבעה דברים שהבוט שלכם חייב לקבל לפני שנוגע בכסף אמיתי:

1. Position sizing. לעולם אל תסכנו יותר מ-1-2% מהחשבון שלכם בעסקה בודדת. אם יש לכם 1000 דולר וה-stop-loss שלכם הוא 5% מתחת לכניסה, גודל הפוזיציה צריך להיות `$1000 * 0.02 / 0.05 = $400`. זה החישוב הכי חשוב במסחר קמעונאי. קודדו אותו כפונקציה, השתמשו בו בכל מקום.

2. לוגיקת Stop-loss. לכל פוזיציה פתוחה צריך stop. תמיד. ללא יוצאים מהכלל. ברגע שיוצרים הזמנה, צרו את ה-stop-loss המקביל. ב-ccxt, מעבירים את זה כ-dict של `params={'stopLoss': {...}}` בבורסות נתמכות, או עוקבים אחריו בקוד שלכם ומציבים הזמנה מותנית.

3. Circuit breaker של max drawdown. אם החשבון שלכם ירד יותר מ-X% ביום או Y% מהשיא, כבו את הבוט. אל תנסו "לסחור את דרככם החוצה". הקוד הזה הציל אותי במרץ 2025 כאשר אסטרטגיה התחילה להיכשל והייתי בחופשה:

```python

def check_drawdown(starting_balance, current_balance, max_dd=0.10):

drawdown = (starting_balance - current_balance) / starting_balance

if drawdown > max_dd:

raise SystemExit(f"[CIRCUIT BREAKER] Drawdown {drawdown:.1%} exceeded {max_dd:.1%}, shutting down")

```

4. מקסימום הזמנות לשעה. הגבילו את קצב הבוט שלכם. אם באג גורם לו לרצות להציב 500 הזמנות בדקה, אתם רוצים cap קשה לתפוס את זה לפני שהבורסה עושה זאת. עקבו אחרי מונה, אפסו אותו כל שעה, סרבו לסחור אם המונה חורג מהסף שלכם.

אף אחד מאלה אינו מרהיב. אף אחד מהם לא הופך את ה-backtest שלכם ליפה יותר. כולם הם מה שמפריד בין בוטים ששורדים שנה לבין בוטים שמתים תוך שבוע.

פריסה לייצור: VPS, מוניטורינג, לוגינג

הבוט שלכם עובד על testnet. הוא עבר backtesting. ניהול סיכונים קיים. עכשיו צריך להריץ אותו 24/7, כי שווקי הקריפטו לא נסגרים.

ה-VPS. אל תריצו את הבוט על הלפטופ שלכם. הלפטופ שלכם נרדם, ה-wifi נופל, הילד שלכם נתקל בכבל החשמל. השתמשו ב-VPS ענן זול. אני משתמש ב-Hetzner (4.50 דולר לחודש ל-CX11) או ב-DigitalOcean (6 דולר לחודש לדרופלט הבסיסי). שניהם בסדר. בחרו datacenter גיאוגרפית קרוב לבורסה שלכם — לBybit, Frankfurt או Singapore. זה חוסך 100-200ms מכל קריאת API.

שירות systemd. על Linux, השתמשו ב-systemd להפעלת הבוט כשירות רקע שמאתחל אוטומטית בעת קריסה. צרו `/etc/systemd/system/tradingbot.service`:

```

[Unit]

Description=Trading Bot

After=network.target

[Service]

Type=simple

User=ubuntu

WorkingDirectory=/home/ubuntu/my-trading-bot

ExecStart=/home/ubuntu/my-trading-bot/venv/bin/python main.py

Restart=always

RestartSec=30

[Install]

WantedBy=multi-user.target

```

ואז `sudo systemctl enable tradingbot && sudo systemctl start tradingbot`. הבוט שלכם כעת שורד אתחולים מחדש ומאתחל אוטומטית אם קורס.

לוגינג. השתמשו במודול `logging` של Python, לא `print`. רשמו לקובץ מתחלף (`TimedRotatingFileHandler`) כדי שהלוגים לא יאכלו את הדיסק שלכם. רשמו כל הזמנה, כל סיגנל, כל שגיאה. כאשר משהו הולך לא כשורה בשלוש לפנות בוקר, לוגים הם הדרך היחידה שלכם להבין מה קרה.

התראות Telegram. הירשמו לבוט Telegram דרך BotFather, ואז שלחו לעצמכם פינג על כל עסקה, כל שגיאה, וכל כיבוי. זה 15 שורות קוד וזו ההבדל בין "הבחנתי בבעיה ביום אותו" ל"הבחנתי שבועיים לאחר מכן אחרי הפסד של 800 דולר".

```python

import requests

def alert(msg):

token = os.getenv('TG_TOKEN')

chat_id = os.getenv('TG_CHAT')

requests.post(f"https://api.telegram.org/bot{token}/sendMessage",

data={'chat_id': chat_id, 'text': msg})

```

קראו ל-`alert()` על כל עסקה, כל שגיאה, וכל נסיעה של circuit breaker. תישנו טוב יותר.

טעויות נפוצות בבניית בוטי מסחר

עשיתי כל אחת מאלה. כך גם כל חברי המפתחים שלי. חסכו לעצמכם את שכר הלימוד.

1. Overfitting. אתם מכוונים את האסטרטגיה עד שה-backtest נראה מושלם. ואז היא נכשלת בחיים. סיבה: התאמתם לרעש, לא לסיגנל. פתרון: תמיד פצלו את הנתונים — אופטימיזציה על טווח אחד, בדיקה על טווח אחר שלא הסתכלתם עליו. אם טווח ה"בדיקה" מתפקד גרוע, האסטרטגיה שלכם overfit.

2. התעלמות מעמלות ו-slippage. ה-backtest שלכם אומר +15%/שנה. מציאות אחרי עמלות taker של 0.1% על 200 עסקות: +3%/שנה. אחרי slippage: -1%. עמלות אכזריות ורוב המתחילים שוכחים אותן. תמיד אפו אותן ל-backtest שלכם (`fees=0.001` ב-vectorbt הוא התחלה טובה).

3. בדיקה רק על שווקי שוורים. האסטרטגיה שלכם עשתה 80% ב-2021. ואז 2022 קרה והיא הפסידה 60%. תמיד בדקו על פני מספר משטרים — כולל 2022 (דובי), 2023 (גלי), 2024 (שורי) לפחות. אם האסטרטגיה שלכם עובדת רק בשווקי שוורים, זו אסטרטגיית שור, לא אסטרטגיית מסחר.

4. אי-טיפול במגבלות rate. ל-ccxt יש טיפול מובנה במגבלות rate (`'enableRateLimit': True`), אבל אם אתם מכים ב-API ממספר threads תקבלו ban. כבדו את הבורסה. השתמשו ב-`exchange.rateLimit` בקריאות sleep שלכם.

5. עיוורון לאחזור. אתם מביאים את המחיר, מחשבים סיגנל, מציבים הזמנה — ובאותן 200ms המחיר זז. לאסטרטגיות מהירות זה חשוב. מדדו את זמן הלולאה שלכם. אם הוא איטי מדי, שמרו נתונים מקומית במקום לביא מחדש.

6. אין persistence. הבוט שלכם מאתחל ושוכח הכל — אילו פוזיציות הוא מחזיק, אילו הזמנות פתוחות. השתמשו ב-SQLite או אפילו בקובץ JSON לשמירת מצב בין אתחולים.

7. הליכה חי מוקדם מדי. הריצו על testnet לפחות שבועיים אחרי שהקוד "סיים". צפו בבאגים שלא תראו ב-backtesting — מילויים חלקיים מוזרים, timeouts של API, נקודות יובשה של סוף שבוע, זוגות חוסר נזילות שבהם ההזמנה שלכם מזיזה את השוק.

שאלות נפוצות

ש: האם אני צריך לדעת מתמטיקה מתקדמת כדי לבנות בוט מסחר?

לא. צריך אריתמטיקה בסיסית, אחוזים, ומושג ממוצע נע. זהו לבוט מתחיל. אפשר להגיע רחוק מאד מבלי לגעת בסטטיסטיקה מעבר ל"מה זה סטיית תקן". אם רוצים לבנות אסטרטגיות למידת מכונה מאוחר יותר, תצטרכו אלגברה לינארית וקצת סטטיסטיקה, אבל זה אופציונלי ועליכם להרוויח את דרככם לשם.

ש: האם Python מהיר מספיק לסחר קריפטו?

ל-99% מהאסטרטגיות הקמעונאיות, כן. Python מבצע לולאות במהירות אלפיות שנייה, ccxt מטפל בכל ה-I/O של הרשת, ומנועי התאמת בורסה לוקחים 20-50ms בכל מקרה. Python הוא "איטי מדי" רק אם אתם מנסים להתחרות עם יוצרי שוק על שינויי ספר הזמנות תת-אלפיות שנייה. אתם כנראה לא. אם אתם, אתם כבר יודעים את התשובה.

ש: כמה הון אני צריך להתחיל איתו?

200-500 דולר להפעלה החיה הראשונה אחרי testnet. מספיק גדול שעמלות לא יאכלו אתכם חיים (בעסקות של 20 דולר, עמלה של 0.1% היא 10% מדולר), מספיק קטן שלא תבכו אם ייעלם. הגדילו רק אחרי 3+ חודשים של הפעלה חיה רווחית עקבית. התחלתי עם 500 דולר ולא הגדלתי ל-5,000 דולר עד חודש שש.

ש: האם הרצת בוט מסחר חוקית?

ברוב השיפוטים, כן — הרצת בוט על חשבונכם עם הכסף שלכם היא חוקית. ניהול כסף של אנשים אחרים היא סיפור אחר ובדרך כלל דורשת רישוי. אם אתם בארה"ב, אתם בסדר להריץ את הבוט שלכם על ההון שלכם. אם אתם גרים במקום עם חוקי קריפטו לא ברורים, עשו מחקר עצמאי. זהו לא ייעוץ משפטי.

ש: האם כדאי לפתוח מקור את הבוט שלי ב-GitHub?

פתחו מקור את ה-framework, שמרו את פרמטרי האסטרטגיה בפרטיות. framework בוט (הפיגומים, ניהול הסיכונים, לוגיקת הביצוע) אינו יתרון תחרותי ושיתופו מסייע לקהילה. הפרמטרים הספציפיים שגורמים לאסטרטגיה שלכם לעבוד — סף הכניסה שלכם, פילטרי המשטר שלכם, עקומות position sizing שלכם — הם היתרון שלכם, ועליכם לשמור אותם בקובץ config פרטי שלעולם לא נוגע ב-GitHub. כך עושים רוב הסוחרים הקמעונאיים הרווחיים.

מחשבות אחרונות

בניית בוט מסחר משלכם אינה קלה, אבל זו גם לא הקסם שהיא נראית מבחוץ. שני סופי שבוע, חשבון testnet, ו-500 דולר יגיעו לרוב הדרך. החלק הקשה אינו הקוד — הקוד הוא בכנות החלק הקל. החלק הקשה הוא המשמעת: backtesting לפני ההליכה חי, כיבוד מגבלות סיכון, אי-שינוי האסטרטגיה בכל פעם שיש שבוע הפסד, והסבלנות להריץ אותו שלושה חודשים לפני שפוסקים עליו.

אם אתם מוכנים להתחיל, תפסו את חשבון ה-Bybit החינמי שלכם כאן ← וצרו מפתח testnet. התקינו Python, התקינו ccxt, העתיקו את דוגמת ה-DCA למעלה, והפעילו אותה. זה יום ראשון. יום שני הוא אסטרטגיית ה-MA. יום שלישי הוא backtesting שלה ב-TradingView ← או vectorbt. יום רביעי הוא ניהול סיכונים. עד יום שביעי, יש לכם בוט אמיתי שרץ על testnet. עד יום 30, אתם רצים חיים עם כסף קטן. עד יום 90, אתם יודעים שזה עובד או שהרגתם אותו ועברתם לרעיון הבא.

רוב המפתחים הקמעונאיים מוותרים לפני יום 30. אלה שלא מוותרים נוטים להבין את זה. היו מהסוג השני.

וזכרו את הכלל האחד שפתחתי איתו: הבוט הראשון שלי הפסיד כסף שני חודשים ברצף. הבוט הראשון שלכם כנראה גם יפסיד כסף. זה לא כישלון, זו שכר לימוד. שלמו אותו, למדו, חזרו על תהליך, ושמרו את ה-position sizing שלכם מספיק הדוק כדי ששכר הלימוד לא יפשיט אתכם.

בהצלחה. לכו לבנות משהו.

*מאמר זה מכיל קישורי שותפים. אם תירשמו דרך הקישורים שלנו, אנו עשויים להרוויח עמלה ללא עלות נוספת לכם. אנו ממליצים רק על כלים שבדקנו.*