Pendahuluan
Algorithmic Trading atau Algo Trading adalah metode melakukan analisis dan menghasilkan sinyal transaksi menggunakan aturan yang telah ditentukan sebelumnya.
Berbeda dengan trading manual yang sangat dipengaruhi emosi, algoritma trading bekerja berdasarkan logika yang konsisten.
Contohnya:
- Beli jika MA20 memotong MA50 dari bawah.
- Jual jika RSI lebih dari 70.
- Stop Loss jika harga turun 5%.
- Ambil keuntungan (Take Profit) pada kenaikan 10%.
Semua aturan tersebut dapat diterjemahkan ke dalam kode Python sehingga proses analisis menjadi lebih cepat, konsisten, dan mudah diuji.
Apa Itu Algorithmic Trading?
Algorithmic Trading adalah proses menggunakan program komputer untuk menghasilkan sinyal beli dan jual berdasarkan aturan tertentu.
Alur sederhananya:
Data Harga
│
▼
Hitung Indikator
│
▼
Evaluasi Aturan
│
▼
Sinyal BUY / SELL
│
▼
Backtesting
│
▼
Eksekusi (Opsional)Pada artikel ini kita akan fokus pada pembuatan sinyal dan evaluasi strategi, bukan pada pengiriman order otomatis ke broker.
Mengapa Menggunakan Python?
Python menjadi bahasa yang sangat populer di dunia quantitative finance karena:
- Sintaks mudah dipelajari.
- Memiliki ekosistem pustaka yang lengkap.
- Cocok untuk analisis data.
- Mendukung visualisasi.
- Mudah diintegrasikan dengan API.
Library yang sering digunakan:
| Library | Fungsi |
|---|---|
| pandas | Mengolah data |
| numpy | Perhitungan numerik |
| yfinance | Mengambil data saham |
| matplotlib | Visualisasi |
| ta | Indikator teknikal |
| backtesting.py | Backtesting strategi |
| vectorbt | Analisis kuantitatif skala besar |
Persiapan Lingkungan
Install library yang dibutuhkan.
pip install yfinance pandas numpy matplotlib taVerifikasi instalasi:
import yfinance as yf
import pandas as pd
import numpy as np
print("Semua library berhasil diimpor.")Mengambil Data Harga Saham
Sebagai contoh kita menggunakan saham BBCA.
import yfinance as yf
df = yf.download(
"BBCA.JK",
period="2y",
interval="1d",
progress=False,
auto_adjust=True
)Lihat beberapa baris pertama.
print(df.head())Kolom yang biasanya tersedia:
- Open
- High
- Low
- Close
- Volume
Visualisasi Harga
import matplotlib.pyplot as plt
plt.figure(figsize=(15,6))
plt.plot(df["Close"])
plt.title("Harga BBCA")
plt.xlabel("Tanggal")
plt.ylabel("Harga")
plt.grid(True)
plt.show()Visualisasi awal membantu memahami pola pergerakan harga.
Membuat Moving Average
Hitung dua Moving Average.
df["MA20"] = (
df["Close"]
.rolling(20)
.mean()
)
df["MA50"] = (
df["Close"]
.rolling(50)
.mean()
)Visualisasikan.
plt.figure(figsize=(15,6))
plt.plot(df["Close"], label="Close")
plt.plot(df["MA20"], label="MA20")
plt.plot(df["MA50"], label="MA50")
plt.legend()
plt.show()Membuat Aturan Trading
Aturan sederhana:
- BUY jika MA20 > MA50.
- SELL jika MA20 < MA50.
Implementasi:
df["Signal"] = 0
df.loc[
df["MA20"] > df["MA50"],
"Signal"
] = 1
df.loc[
df["MA20"] < df["MA50"],
"Signal"
] = -1Arti nilai:
| Nilai | Keterangan |
|---|---|
| 1 | BUY |
| -1 | SELL |
| 0 | Tidak ada sinyal |
Menampilkan Sinyal
print(
df[
["Close","MA20","MA50","Signal"]
].tail()
)Contoh hasil:
| Close | MA20 | MA50 | Signal |
|---|---|---|---|
| 9150 | 9020 | 8950 | 1 |
| 9180 | 9045 | 8965 | 1 |
| 9050 | 9000 | 9020 | -1 |
Menentukan Posisi
Kita hanya ingin mengetahui apakah sedang memegang saham atau tidak.
df["Position"] = (
df["Signal"]
.replace(-1,0)
.ffill()
)Interpretasi:
| Position | Arti |
|---|---|
| 1 | Sedang memiliki saham |
| 0 | Tidak memiliki posisi |
Menghitung Return Harian
df["Return"] = (
df["Close"]
.pct_change()
)Return strategi:
df["Strategy"] = (
df["Return"]
*
df["Position"].shift(1)
)Dengan cara ini, return hanya dihitung ketika strategi sedang berada pada posisi beli.
Menghitung Performa Strategi
Return kumulatif:
df["Cumulative Market"] = (
1 + df["Return"]
).cumprod()
df["Cumulative Strategy"] = (
1 + df["Strategy"]
).cumprod()Visualisasikan.
plt.figure(figsize=(15,6))
plt.plot(
df["Cumulative Market"],
label="Buy & Hold"
)
plt.plot(
df["Cumulative Strategy"],
label="Strategy"
)
plt.legend()
plt.show()Grafik ini memperlihatkan apakah strategi mampu mengungguli pendekatan Buy & Hold.
Mengapa Backtesting Penting?
Sebelum digunakan pada data nyata, setiap strategi perlu diuji menggunakan data historis.
Tujuannya:
- Mengukur konsistensi strategi.
- Mengetahui risiko.
- Menghitung potensi keuntungan.
- Mengidentifikasi kelemahan strategi.
Backtesting bukan jaminan bahwa strategi akan berhasil di masa depan, tetapi merupakan langkah penting untuk mengevaluasi logika yang digunakan.
Kesalahan Umum Pemula
Beberapa kesalahan yang sering dilakukan saat mulai belajar algorithmic trading:
- Menggunakan terlalu banyak indikator sekaligus.
- Tidak memperhitungkan biaya transaksi.
- Tidak menguji strategi pada berbagai kondisi pasar.
- Mengoptimalkan parameter secara berlebihan (overfitting).
- Langsung menggunakan uang sungguhan tanpa backtesting dan simulasi.
Memulai dengan strategi sederhana justru akan membantu memahami konsep dasar dengan lebih baik.
Mengapa Tidak Cukup Menggunakan Moving Average?
Moving Average sangat baik untuk mengidentifikasi tren, tetapi memiliki kelemahan:
- Sinyal sering terlambat (lagging indicator).
- Banyak sinyal palsu saat pasar bergerak mendatar (sideways).
- Tidak menunjukkan apakah harga sudah terlalu mahal atau terlalu murah.
Karena itu, banyak trader menggabungkan Moving Average dengan indikator lain.
Menambahkan RSI (Relative Strength Index)
RSI digunakan untuk mengukur kekuatan momentum harga.
Install pustaka ta jika belum tersedia:
pip install taHitung RSI:
from ta.momentum import RSIIndicator
rsi = RSIIndicator(
close=df["Close"],
window=14
)
df["RSI"] = rsi.rsi()Lihat hasilnya:
print(
df[
["Close","RSI"]
].tail()
)Menggunakan RSI Sebagai Filter
Contoh aturan:
- BUY jika MA20 > MA50 dan RSI < 70.
- SELL jika MA20 < MA50 atau RSI > 70.
Implementasi:
df["Signal"] = 0
buy_condition = (
(df["MA20"] > df["MA50"])
&
(df["RSI"] < 70)
)
sell_condition = (
(df["MA20"] < df["MA50"])
|
(df["RSI"] > 70)
)
df.loc[buy_condition, "Signal"] = 1
df.loc[sell_condition, "Signal"] = -1Filter seperti ini membantu mengurangi sinyal beli ketika harga sudah terlalu tinggi.
Menambahkan MACD
MACD sering digunakan untuk mengonfirmasi arah tren.
from ta.trend import MACD
macd = MACD(
close=df["Close"]
)
df["MACD"] = macd.macd()
df["MACD_SIGNAL"] = macd.macd_signal()Konfirmasi bullish:
buy = (
df["MACD"] >
df["MACD_SIGNAL"]
)Konfirmasi bearish:
sell = (
df["MACD"] <
df["MACD_SIGNAL"]
)Menggabungkan beberapa indikator dapat membantu mengurangi sinyal yang kurang berkualitas, meskipun tidak menghilangkan risiko sepenuhnya.
Menambahkan Stop Loss
Setiap strategi sebaiknya memiliki batas kerugian.
Misalnya:
- Harga beli = Rp9.000
- Stop Loss = 5%
stop_loss = 0.05Harga stop:
stop_price = (
buy_price *
(1 - stop_loss)
)Jika harga turun di bawah nilai tersebut, posisi ditutup.
Menambahkan Take Profit
Contoh target keuntungan:
take_profit = 0.10Harga target:
target_price = (
buy_price *
(1 + take_profit)
)Ketika harga mencapai target, posisi dapat ditutup untuk mengunci keuntungan.
Position Sizing
Selain menentukan kapan membeli, penting juga menentukan berapa besar modal yang digunakan.
Misalnya:
- Modal = Rp100.000.000
- Risiko maksimum per transaksi = 2%
capital = 100_000_000
risk = 0.02Dana yang siap dipertaruhkan:
risk_amount = (
capital * risk
)Pendekatan ini membantu mengendalikan risiko sehingga satu transaksi tidak terlalu memengaruhi keseluruhan portofolio.
Mencatat Setiap Transaksi
Simpan histori transaksi.
trades = []Contoh pencatatan:
trades.append({
"Buy": buy_price,
"Sell": sell_price,
"Profit": profit
})Kemudian ubah menjadi DataFrame.
trade_df = pd.DataFrame(trades)
print(trade_df)Contoh hasil:
| Buy | Sell | Profit |
|---|---|---|
| 9000 | 9450 | 5.0% |
| 8800 | 8600 | -2.3% |
Riwayat ini sangat berguna untuk evaluasi strategi.
Menghitung Win Rate
Win Rate menunjukkan persentase transaksi yang menghasilkan keuntungan.
wins = len(
trade_df[
trade_df["Profit"] > 0
]
)
total = len(trade_df)Perhitungan:
win_rate = (
wins / total
) * 100Contoh:
Win Rate : 68%Win Rate tinggi belum tentu berarti strategi terbaik, tetapi dapat menjadi salah satu indikator yang berguna.
Menghitung Profit Factor
Profit Factor membandingkan total keuntungan dengan total kerugian.
gross_profit = (
trade_df[
trade_df["Profit"] > 0
]["Profit"]
).sum()gross_loss = abs(
trade_df[
trade_df["Profit"] < 0
]["Profit"]
).sum()Perhitungan:
profit_factor = (
gross_profit /
gross_loss
)Interpretasi sederhana:
| Profit Factor | Arti |
|---|---|
| < 1 | Strategi merugi |
| 1–1.5 | Perlu evaluasi |
| > 1.5 | Cukup baik |
| > 2 | Sangat baik (tetap perlu diuji pada berbagai kondisi pasar) |
Menghitung Maximum Drawdown
Drawdown menunjukkan penurunan terbesar dari puncak nilai portofolio.
cum = (
1 + df["Strategy"]
).cumprod()Nilai tertinggi sebelumnya:
peak = cum.cummax()Drawdown:
drawdown = (
(cum - peak)
/
peak
)Nilai maksimum:
max_dd = (
drawdown.min()
)Contoh hasil:
Maximum Drawdown
-8.6%Semakin kecil drawdown, umumnya semakin stabil performa strategi.
Menampilkan Titik BUY dan SELL
Grafik lebih mudah dipahami jika dilengkapi penanda transaksi.
buy = df[
df["Signal"] == 1
]
sell = df[
df["Signal"] == -1
]Visualisasi:
plt.figure(figsize=(16,7))
plt.plot(
df["Close"]
)
plt.scatter(
buy.index,
buy["Close"],
marker="^",
s=100
)
plt.scatter(
sell.index,
sell["Close"],
marker="v",
s=100
)
plt.show()Grafik ini membantu memverifikasi apakah sinyal yang dihasilkan sudah sesuai dengan logika strategi.
Menguji Banyak Saham
Daripada hanya menggunakan BBCA, lakukan pengujian pada beberapa emiten.
tickers = [
"BBCA.JK",
"BBRI.JK",
"BMRI.JK",
"TLKM.JK"
]Loop:
results = []
for ticker in tickers:
print(ticker)Kemudian simpan hasil evaluasi masing-masing saham.
Contoh:
| Ticker | Return | Win Rate | Drawdown |
|---|---|---|---|
| BBCA | 28% | 70% | -8% |
| BBRI | 23% | 66% | -11% |
| BMRI | 31% | 72% | -9% |
| TLKM | 18% | 61% | -10% |
Dengan cara ini kita dapat mengetahui apakah strategi bekerja secara konsisten pada berbagai saham.
Best Practice
Beberapa hal yang perlu diperhatikan:
- Gunakan lebih dari satu periode pengujian (bull market, bear market, dan sideways).
- Sertakan biaya transaksi dan slippage jika memungkinkan.
- Pisahkan logika indikator, sinyal, dan evaluasi ke dalam fungsi yang berbeda.
- Simpan hasil pengujian agar mudah dibandingkan.
- Jangan memilih parameter hanya karena memberikan hasil terbaik pada satu dataset (overfitting).
Arsitektur Sistem
Sebelum mulai menulis kode, buatlah arsitektur sederhana.
Yahoo Finance
│
▼
Download Data Harga
│
▼
Perhitungan Indikator
│
▼
Trading Strategy Engine
│
┌───────────────┼───────────────┐
▼ ▼ ▼
Backtesting AI Sentiment Risk Management
│ │ │
└───────────────┼───────────────┘
▼
Trading Dashboard
│
▼
Telegram NotificationDengan desain seperti ini, setiap komponen memiliki tanggung jawab yang jelas.
Membuat Struktur Project
Daripada semua kode berada di satu file, pisahkan menjadi beberapa modul.
algo-trading/
├── app.py
├── config.py
├── data.py
├── indicators.py
├── strategy.py
├── backtest.py
├── portfolio.py
├── sentiment.py
├── telegram.py
├── dashboard.py
├── database.py
├── utils.py
├── requirements.txt
├── .env
└── data/Penjelasan:
data.py→ mengambil data harga.indicators.py→ menghitung indikator teknikal.strategy.py→ aturan BUY dan SELL.backtest.py→ evaluasi strategi.portfolio.py→ simulasi modal.telegram.py→ notifikasi.dashboard.py→ tampilan Streamlit.
Struktur modular memudahkan pengujian dan pengembangan fitur baru.
Menyimpan Hasil Backtesting
Daripada hanya menampilkan hasil di terminal, simpan ke database.
Menggunakan SQLite:
import sqlite3
conn = sqlite3.connect("backtest.db")
result.to_sql(
"strategy_result",
conn,
if_exists="append",
index=False
)
conn.close()Contoh tabel:
| Tanggal | Ticker | Return | Win Rate | Drawdown |
|---|---|---|---|---|
| 2026-07-24 | BBCA | 28.4% | 70% | -8.3% |
| 2026-07-24 | BMRI | 31.1% | 72% | -9.1% |
Menyimpan histori memudahkan perbandingan antarversi strategi.
Membuat Dashboard dengan Streamlit
Install:
pip install streamlitContoh dashboard:
import streamlit as st
st.title("Algorithmic Trading Dashboard")
st.dataframe(result)Tambahkan metrik utama:
st.metric(
"Total Return",
"28.4%"
)
st.metric(
"Win Rate",
"70%"
)Dashboard akan lebih informatif dibandingkan output terminal.
Menampilkan Kurva Ekuitas
Kurva ekuitas (equity curve) menunjukkan perkembangan nilai portofolio dari waktu ke waktu.
st.line_chart(
df["Cumulative Strategy"]
)Jika dibandingkan dengan Buy & Hold:
chart = df[
[
"Cumulative Strategy",
"Cumulative Market"
]
]
st.line_chart(chart)Grafik ini membantu mengevaluasi apakah strategi benar-benar memberikan nilai tambah.
Menggabungkan AI Sentiment
Pada artikel sebelumnya kita telah membuat sistem analisis sentimen.
Sekarang gunakan hasil tersebut sebagai filter.
Contoh aturan:
- BUY jika:
- MA20 > MA50
- RSI < 70
- Sentimen AI = Positif
- SELL jika:
- MA20 < MA50
- Sentimen AI = Negatif
Contoh DataFrame:
| Ticker | Teknikal | Sentimen | Keputusan |
|---|---|---|---|
| BBCA | Bullish | Positif | BUY |
| BMRI | Bullish | Netral | HOLD |
| TLKM | Bearish | Negatif | SELL |
Dengan pendekatan ini, sinyal teknikal dapat diperkaya menggunakan informasi dari berita.
Mengirim Sinyal ke Telegram
Setelah strategi menghasilkan sinyal, kirim notifikasi.
Contoh isi pesan:
📈 Trading Signal
Ticker : BBCA
Signal : BUY
Harga : Rp9.150
Moving Average : Bullish
RSI : 58
AI Sentiment : Positif
Risk Level : RendahInvestor dapat menerima informasi penting tanpa harus membuka dashboard.
Menjalankan dengan Docker
Contoh Dockerfile:
FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python","app.py"]Build:
docker build -t algo-trading .Run:
docker run -d algo-tradingDocker memastikan lingkungan pengembangan dan produksi tetap konsisten.
Deploy ke AWS EC2 atau VPS
Langkah umum:
- Siapkan server Linux.
- Install Docker.
- Salin proyek ke server.
- Jalankan menggunakan Docker Compose atau
systemd. - Simpan konfigurasi di file
.env. - Gunakan
cronatau scheduler untuk menjalankan proses sesuai kebutuhan.
Bagi pengguna AWS, Anda juga dapat menjalankan aplikasi di EC2 dan mengakses dashboard melalui reverse proxy seperti Nginx.
Logging
Tambahkan logging agar aktivitas aplikasi tercatat.
import logging
logging.basicConfig(
filename="algo.log",
level=logging.INFO
)
logging.info("Strategy started")Jika terjadi kesalahan:
try:
run_strategy()
except Exception as e:
logging.exception(e)Log sangat membantu ketika aplikasi berjalan terus-menerus di server.
Optimasi Strategi
Setelah sistem berjalan, lakukan evaluasi secara berkala.
Beberapa parameter yang dapat diuji:
| Parameter | Contoh |
|---|---|
| MA Cepat | 10, 20, 30 |
| MA Lambat | 50, 100, 200 |
| RSI | 14, 21 |
| Stop Loss | 3%, 5%, 8% |
| Take Profit | 8%, 10%, 15% |
Lakukan pengujian pada beberapa periode dan berbagai saham untuk melihat apakah strategi tetap konsisten.
Keterbatasan Algorithmic Trading
Walaupun algorithmic trading sangat membantu, ada beberapa keterbatasan:
- Strategi yang baik pada data historis belum tentu berhasil di masa depan.
- Data yang kurang lengkap dapat menghasilkan kesimpulan yang keliru.
- Kondisi pasar dapat berubah sehingga parameter perlu dievaluasi secara berkala.
- Biaya transaksi, pajak, dan slippage dapat memengaruhi hasil nyata.
- Algoritma tidak memahami peristiwa luar biasa seperti perubahan regulasi atau kejadian geopolitik kecuali informasi tersebut dimasukkan ke dalam sistem.
Best Practice
Agar proyek mudah dikembangkan:
- Gunakan virtual environment.
- Pisahkan setiap komponen ke modul yang berbeda.
- Simpan konfigurasi sensitif di
.env. - Dokumentasikan perubahan strategi.
- Uji strategi pada berbagai kondisi pasar.
- Tambahkan unit test untuk fungsi-fungsi penting.
- Simpan hasil backtesting untuk setiap versi strategi.
FAQ
Apakah algorithmic trading selalu menghasilkan keuntungan?
Tidak. Algorithmic trading membantu menerapkan aturan secara konsisten, tetapi keuntungan tetap bergantung pada kualitas strategi, kondisi pasar, dan pengelolaan risiko.
Apakah saya harus langsung membuat trading bot otomatis?
Tidak. Sebaiknya mulai dari analisis data dan backtesting. Setelah strategi benar-benar dipahami dan diuji, barulah mempertimbangkan otomatisasi sesuai aturan broker dan regulasi yang berlaku.
Apakah Python cukup cepat?
Untuk riset, analisis, dan backtesting, Python sangat memadai. Pada kebutuhan dengan frekuensi sangat tinggi (high-frequency trading), sering digunakan teknologi dan bahasa pemrograman yang lebih khusus.
Kesimpulan
Dalam tiga bagian artikel ini kita telah mempelajari dasar-dasar algorithmic trading menggunakan Python, mulai dari pengambilan data harga, perhitungan indikator teknikal, pembuatan sinyal BUY dan SELL, hingga evaluasi performa strategi.
Selanjutnya, sistem tersebut dikembangkan menjadi aplikasi yang lebih terstruktur dengan dashboard, database, notifikasi Telegram, serta integrasi analisis sentimen berbasis AI. Pendekatan ini memberikan fondasi yang baik untuk membangun platform analisis saham yang lebih lengkap.
Yang terpenting, gunakan algorithmic trading sebagai alat bantu pengambilan keputusan yang didukung oleh pengujian dan manajemen risiko yang baik, bukan sebagai jaminan keuntungan.
