🐍『TradingViewのストラテジーで自動売買したい...』を現実にする方法【第4回：GMOコイン × TradingView × Python 完全攻略編】

変更前：最小注文数量 10,000通貨
変更後：最小注文数量 100通貨 ← 🔥これがデカい

変更前：API手数料 1通貨ごとに0.002円
変更後：約定金額 × 0.002%

TradingView
   │
   │ ストラテジーのシグナル発火
   ▼
Webhook送信（JSON）
   │
   ▼
サーバー（GCF (Google Cloud Functions) / VPS）
   │
   │ Pythonでリクエスト処理
   ▼
GMOコイン API
   │
   │ 注文実行
   ▼
自動売買完了！🎉

1. GMOコインにログイン
2. 「API」メニューへ
3. 「APIキー新規追加」をクリック
4. 以下を設定：
   - APIキー名：自由（例：TradingViewBot）
   - 権限：注文、照会にチェック
5. 「追加」をクリック
6. APIキーとシークレットをメモ（二度と表示されない！）

# gmo_fx_api.py
import hmac
import hashlib
import time
import json
import requests
from datetime import datetime

class GMOFxAPI:
    """GMOコイン 外国為替FX API クライアント"""

    BASE_URL = "https://forex-api.coin.z.com/private"

    def __init__(self, api_key: str, api_secret: str):
        self.api_key = api_key
        self.api_secret = api_secret

    def _create_signature(self, timestamp: str, method: str, path: str, body: str = "") -> str:
        """署名を作成"""
        text = timestamp + method + path + body
        sign = hmac.new(
            self.api_secret.encode(),
            text.encode(),
            hashlib.sha256
        ).hexdigest()
        return sign

    def _request(self, method: str, path: str, data: dict = None) -> dict:
        """APIリクエストを実行"""
        timestamp = str(int(time.time() * 1000))
        body = json.dumps(data) if data else ""

        headers = {
            "API-KEY": self.api_key,
            "API-TIMESTAMP": timestamp,
            "API-SIGN": self._create_signature(timestamp, method, path, body),
            "Content-Type": "application/json"
        }

        url = self.BASE_URL + path

        if method == "GET":
            response = requests.get(url, headers=headers)
        elif method == "POST":
            response = requests.post(url, headers=headers, data=body)

        return response.json()

    def get_account(self) -> dict:
        """口座情報を取得"""
        return self._request("GET", "/v1/account")

    def get_positions(self) -> dict:
        """ポジション一覧を取得"""
        return self._request("GET", "/v1/openPositions")

    def place_order(self, symbol: str, side: str, size: int) -> dict:
        """
        成行注文を出す
        symbol: "USD_JPY" など
        side: "BUY" or "SELL"
        size: 取引数量（100通貨単位）
        """
        data = {
            "symbol": symbol,
            "side": side,
            "executionType": "MARKET",
            "size": str(size)
        }
        return self._request("POST", "/v1/order", data)

    def close_position(self, position_id: str, size: int) -> dict:
        """ポジションを決済"""
        data = {
            "positionId": position_id,
            "executionType": "MARKET",
            "size": str(size)
        }
        return self._request("POST", "/v1/closeOrder", data)

    def close_all_positions(self, symbol: str) -> list:
        """指定通貨ペアの全ポジションを決済"""
        positions = self.get_positions()
        results = []

        if positions.get("data"):
            for pos in positions["data"]["list"]:
                if pos["symbol"] == symbol:
                    result = self.close_position(
                        pos["positionId"],
                        int(pos["size"])
                    )
                    results.append(result)

        return results

import os
from gmo_fx_api import GMOFxAPI

# 初期化
api = GMOFxAPI(
    api_key=os.environ["GMO_API_KEY"],
    api_secret=os.environ["GMO_API_SECRET"]
)

# 口座情報を確認
account = api.get_account()
print(f"口座残高: {account['data']['balance']}円")

# USD/JPYを100通貨買い
result = api.place_order("USD_JPY", "BUY", 100)
print(f"注文結果: {result}")

# ポジション確認
positions = api.get_positions()
print(f"保有ポジション: {positions}")

# 全決済
api.close_all_positions("USD_JPY")
print("全決済完了！")

# webhook_server.py
import os
import json
from flask import Flask, request, jsonify
from gmo_fx_api import GMOFxAPI

app = Flask(__name__)

# API初期化
api = GMOFxAPI(
    api_key=os.environ["GMO_API_KEY"],
    api_secret=os.environ["GMO_API_SECRET"]
)

# セキュリティ用のシークレット
WEBHOOK_SECRET = os.environ.get("WEBHOOK_SECRET", "your_secret_here")

@app.route("/webhook", methods=["POST"])
def webhook():
    """TradingViewからのWebhookを処理"""
    try:
        # シークレット検証
        data = request.json
        if data.get("secret") != WEBHOOK_SECRET:
            return jsonify({"error": "Unauthorized"}), 401

        # シグナル取得
        action = data.get("action")  # "BUY" or "SELL" or "CLOSE"
        symbol = data.get("symbol", "USD_JPY")
        size = int(data.get("size", 100))

        print(f"受信: action={action}, symbol={symbol}, size={size}")

        # 注文実行
        if action == "BUY":
            # 売りポジションがあれば決済
            api.close_all_positions(symbol)
            result = api.place_order(symbol, "BUY", size)

        elif action == "SELL":
            # 買いポジションがあれば決済
            api.close_all_positions(symbol)
            result = api.place_order(symbol, "SELL", size)

        elif action == "CLOSE":
            result = api.close_all_positions(symbol)

        else:
            return jsonify({"error": "Invalid action"}), 400

        print(f"結果: {result}")
        return jsonify({"success": True, "result": result})

    except Exception as e:
        print(f"エラー: {e}")
        return jsonify({"error": str(e)}), 500


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

# main.py
import os
import json
from flask import jsonify
from gmo_fx_api import GMOFxAPI

api = GMOFxAPI(
    api_key=os.environ["GMO_API_KEY"],
    api_secret=os.environ["GMO_API_SECRET"]
)

WEBHOOK_SECRET = os.environ["WEBHOOK_SECRET"]

def webhook_handler(request):
    """Cloud Functionsのエントリーポイント"""
    try:
        # ボディをパース
        body = request.get_json()

        # シークレット検証
        if body.get("secret") != WEBHOOK_SECRET:
            return jsonify({"error": "Unauthorized"}), 401

        action = body.get("action")
        symbol = body.get("symbol", "USD_JPY")
        size = int(body.get("size", 100))

        # 注文実行
        if action == "BUY":
            api.close_all_positions(symbol)
            result = api.place_order(symbol, "BUY", size)
        elif action == "SELL":
            api.close_all_positions(symbol)
            result = api.place_order(symbol, "SELL", size)
        elif action == "CLOSE":
            result = api.close_all_positions(symbol)
        else:
            return jsonify({"error": "Invalid action"}), 400

        return jsonify({"success": True, "result": result}), 200

    except Exception as e:
        return jsonify({"error": str(e)}), 500

//@version=5
strategy("MA Cross Strategy", overlay=true)

// パラメータ
shortPeriod = input.int(5, "短期MA")
longPeriod = input.int(20, "長期MA")

// 移動平均計算
shortMA = ta.sma(close, shortPeriod)
longMA = ta.sma(close, longPeriod)

// プロット
plot(shortMA, color=color.blue, title="短期MA")
plot(longMA, color=color.red, title="長期MA")

// エントリー条件
longCondition = ta.crossover(shortMA, longMA)
shortCondition = ta.crossunder(shortMA, longMA)

// エントリー
if longCondition
    strategy.entry("Long", strategy.long)
    alert('{"secret":"your_secret","action":"BUY","symbol":"USD_JPY","size":"1000"}', alert.freq_once_per_bar)

if shortCondition
    strategy.entry("Short", strategy.short)
    alert('{"secret":"your_secret","action":"SELL","symbol":"USD_JPY","size":"1000"}', alert.freq_once_per_bar)

1. TradingViewでストラテジーをチャートに追加
2. 右上の「アラート」ボタンをクリック
3. 以下を設定：
   - 条件：ストラテジー名 → 注文が発注された時
   - Webhook URL：https://your-server.com/webhook
   - メッセージ：そのまま（ストラテジーのalert()が使われる）
4. 「作成」をクリック

# 1. VPSを契約（ConoHa、さくら、Vultrなど）

# 2. SSHで接続
ssh root@your-server-ip

# 3. Python環境構築
apt update && apt install python3 python3-pip
pip3 install flask requests

# 4. ファイルをアップロード
scp gmo_fx_api.py webhook_server.py root@your-server-ip:~/

# 5. 環境変数を設定
export GMO_API_KEY="your_key"
export GMO_API_SECRET="your_secret"
export WEBHOOK_SECRET="your_webhook_secret"

# 6. 起動（screenで永続化）
screen -S bot
python3 webhook_server.py

# Ctrl+A, D で抜ける

# 1. GCPプロジェクトを作成
# 2. Cloud Functionsで関数を作成
# 3. ランタイムをPython 3.xに設定
# 4. 環境変数を設定（GMO_API_KEY, GMO_API_SECRET, WEBHOOK_SECRET）
# 5. HTTPトリガーを有効化
# 6. TradingViewのWebhook URLにCloud FunctionsのURLを設定

# test_api.py
from gmo_fx_api import GMOFxAPI

api = GMOFxAPI("your_key", "your_secret")

# 口座情報取得できるか確認
account = api.get_account()
print(account)

# 小さい注文でテスト（100通貨）
result = api.place_order("USD_JPY", "BUY", 100)
print(result)

# すぐ決済
api.close_all_positions("USD_JPY")

# curlでWebhookをシミュレート
curl -X POST http://localhost:5000/webhook \
  -H "Content-Type: application/json" \
  -d '{"secret":"your_secret","action":"BUY","symbol":"USD_JPY","size":"100"}'

import time

def safe_request(func, *args, **kwargs):
    """レート制限を守る"""
    time.sleep(1)  # 1秒待つ
    return func(*args, **kwargs)

def place_order_with_retry(api, symbol, side, size, max_retries=3):
    for i in range(max_retries):
        try:
            result = api.place_order(symbol, side, size)
            if result.get("status") == 0:
                return result
            print(f"注文失敗（{i+1}回目）: {result}")
        except Exception as e:
            print(f"エラー（{i+1}回目）: {e}")
        time.sleep(2)
    raise Exception("注文に失敗しました")