LDBD
/
← All posts

Building an Unattended ChatGPT Prediction Bot with the OpenAI API

A Python script that calls the OpenAI API directly to submit LDBD predictions. Compared with the Gemma bot, the two annoying parts — fetching news and parsing JSON — mostly disappear thanks to `web_search` and structured outputs.

The previous post walked through plugging LDBD into ChatGPT through the connector. The biggest selling point of that approach was cost: if you're already paying for a ChatGPT subscription, you can run a prediction bot inside that same subscription with no extra API bill.

There was a catch with fully unattended operation, though. The write tool may show a confirmation modal, and how that modal behaves under scheduled tasks is something you'd still need to verify yourself.

So for the last approach I skipped the chat window entirely. A Python script calls the OpenAI API directly and posts the result to LDBD's API. Wired up to cron or launchd, nobody needs to be in the loop. The cost structure flips though — regardless of any ChatGPT subscription you have, every API call is billed separately as OpenAI API usage.

Compared with the connector approach, this gets much closer to true unattended operation. The responsibility for keys, logs, scheduling, and cost ends up squarely on my side instead.

Three things to have ready: an OpenAI API key, Python 3, and an LDBD account. Plus an environment for the script to run daily — launchd if you leave a laptop on, but the same code runs on a small server or in GitHub Actions just as well.

What changes vs. the connector

Both approaches can use OpenAI-family models. The difference is who triggers the run and who owns the operational burden.

  • Connector — natural-language commands inside the ChatGPT chat. A human has to open the chat and trigger it. ChatGPT's scheduled task feature gives you something like automation, but the confirm modal can still show up on write tools, so “fully unattended” isn't guaranteed.
  • Direct API call — my Python script runs on a fixed schedule and submits straight to LDBD. Zero user intervention. The flip side: if something fails, it's on me. Keys, logs, scheduler, cost management — all of that becomes my problem. In exchange, this gives you the most automation freedom.

What overlaps with the Gemma bot, and what differs

The shape is the same as the Gemma bot: (1) fetch prices and sentiment from LDBD /api/v1/assets/[symbol] → (2) send the prompt to an LLM → (3) submit to LDBD /api/v1/predictions. The difference lives in the middle step — the LLM call.

The Gemma version looked like this:

# Gemma (agent.py)
news = get_news(symbol, NEWS_LIMIT)         # fetch news via yfinance
prompt = build_prompt(asset, news)
resp = mlx_lm.generate(model, ...)
m = re.search(r"\{.*\}", text, re.DOTALL)  # scrape JSON out with regex
parsed = json.loads(m.group(0))

In the ChatGPT version, two pieces disappear:

# ChatGPT (agent.py)
prompt = build_prompt(asset)                # no news-fetch code
response = client.responses.create(
    model=MODEL,
    input=prompt,
    tools=[{"type": "web_search"}],         # GPT searches on its own
    text={
        "format": {
            "type": "json_schema",
            "schema": SCHEMA,
            "strict": True,                 # schema enforced
        }
    },
)
parsed = json.loads(response.output_text)   # no regex needed

The two most annoying parts of the Gemma version basically disappear.

  1. GPT calls web_search itself — the yfinance dependency goes away. With Gemma I often got nothing back for Korean tickers, but web_search has GPT generate its own queries and pull in both English and Korean coverage. In a dry run I saw a Korean crypto outlet quoted for BTC-USD and a domestic ETF analysis outlet quoted for 069500.KS.
  2. Structured outputs enforce valid JSON — no regex needed to scrape the response. The first dry run parsed cleanly for all five assets. With Gemma, if the model output drifted even slightly from JSON format, the regex match would fail and the bot would have to skip that asset entirely with no result.

As you'll see below, these two — built-in web search and structured outputs — are the biggest draw of the ChatGPT API approach.

Step 1. LDBD bot identity + API key

Same as the earlier posts. In /settings create an AI Bot identity and issue an API key. If you want to run daily and weekly bots separately, two identities keep the score comparisons clean. The key string appears on screen only once, so copy it somewhere safe immediately.

Step 2. Python environment

Create a project directory, then create and activate a virtual environment. Dependencies differ from the Gemma bot's MLX venv, so keeping a separate venv is cleaner.

mkdir -p ~/projects/ldbd-bot/chatgpt-agent
cd ~/projects/ldbd-bot/chatgpt-agent

python3 -m venv .venv
source .venv/bin/activate

pip install openai requests

Step 3. agent.py

The code below is a working minimum version. It looks long, but there are really only five places to look at — the watchlist, the JSON schema, the prompt builder, the OpenAI call, and the main loop. Save it as agent.py in your project directory, and it should run as-is.

# agent.py — ChatGPT (OpenAI Responses API) LDBD prediction bot
import json, os, sys, time
import requests
from openai import OpenAI
from typing import Optional

BASE = os.environ.get("LDBD_BASE_URL", "https://ldbd.app").rstrip("/")
LDBD_KEY = os.environ["LDBD_API_KEY"]
OPENAI_KEY = os.environ["OPENAI_API_KEY"]
MODEL = os.environ.get("OPENAI_MODEL", "gpt-5.4")
TIMEFRAME = os.environ.get("TIMEFRAME", "1w")
DRY_RUN = os.environ.get("DRY_RUN", "0") in ("1", "true", "yes")

LDBD_H = {"Authorization": f"Bearer {LDBD_KEY}", "Content-Type": "application/json"}
WATCHLIST = ["VOO", "QQQ", "GLD", "BTC-USD", "069500.KS"]

TIMEFRAME_LABEL = {"1d": "1 trading day", "1w": "1 week", "1m": "1 month",
                   "6m": "6 months", "1y": "1 year"}
TIMEFRAME_FOCUS = {
    "1d": "short-term catalysts (earnings, macro prints, news events)",
    "1w": "short-term technical trend + upcoming calendar items",
    "1m": "monthly earnings / macro cycle",
    "6m": "medium-term macro regime",
    "1y": "annual fundamentals and macro regime",
}
if TIMEFRAME not in TIMEFRAME_LABEL:
    raise ValueError(f"Unsupported TIMEFRAME: {TIMEFRAME}")

client = OpenAI(api_key=OPENAI_KEY)  # built once, reused across all calls

PREDICTION_SCHEMA = {
    "type": "object",
    "properties": {
        "direction": {"type": "string", "enum": ["up", "down"]},
        "reasoning": {"type": "string"},
    },
    "required": ["direction", "reasoning"],
    "additionalProperties": False,
}

def get_asset(symbol):
    r = requests.get(f"{BASE}/api/v1/assets/{symbol}", headers=LDBD_H, timeout=10)
    r.raise_for_status()
    return r.json()

def build_prompt(asset):
    a = asset["asset"]
    prices = list(reversed(asset.get("recent_prices", [])[:10]))
    price_str = "\n".join(f"  {p['date']}: {p['close']:.2f}" for p in prices) or "  (none)"
    horizon = TIMEFRAME_LABEL[TIMEFRAME]
    focus = TIMEFRAME_FOCUS[TIMEFRAME]
    today = time.strftime("%Y-%m-%d")
    return f"""You are a financial market analyst. Today is {today} and you are predicting the price direction over the next {horizon}.

Asset: {a['symbol']} ({a.get('display_name', '')})  Sector: {a.get('sector', 'N/A')}

Last 10 closes (oldest → newest):
{price_str}

Task:
1. Use the web_search tool actively to look up recent news for this asset. English and Korean sources are both fine.
2. Focus on {focus}.
3. Combine the price trend and the news you searched to decide the direction over the next {horizon}.
4. Reasoning: 2-3 English sentences citing a specific news headline or price pattern.
"""

def ask_openai(prompt):
    response = client.responses.create(
        model=MODEL,
        input=prompt,
        tools=[{"type": "web_search"}],
        text={"format": {
            "type": "json_schema",
            "name": "prediction",
            "schema": PREDICTION_SCHEMA,
            "strict": True,
        }},
    )
    raw = response.output_text
    parsed = json.loads(raw)
    direction = str(parsed.get("direction", "")).lower()
    if direction not in ("up", "down"):
        return None
    return {"direction": direction, "reasoning": str(parsed.get("reasoning", ""))[:2000]}

def submit(symbol, direction, reasoning):
    r = requests.post(
        f"{BASE}/api/v1/predictions",
        headers=LDBD_H,
        json={"asset_symbol": symbol, "direction": direction,
              "timeframe": TIMEFRAME, "reasoning": reasoning},
        timeout=60,
    )
    return r.status_code, r.text[:200]

def main():
    print(f"▸ model={MODEL}  timeframe={TIMEFRAME}  dry_run={DRY_RUN}")
    for symbol in WATCHLIST:
        print(f"\n▶ {symbol}")
        try:
            asset = get_asset(symbol)
        except Exception as e:
            print(f"  ⚠️  asset fetch failed: {e}")
            continue
        try:
            pred = ask_openai(build_prompt(asset))
        except Exception as e:
            print(f"  ⚠️  OpenAI call failed: {e}")
            continue
        if not pred:
            print("  ⚠️  no valid response")
            continue
        print(f"  → {pred['direction']}: {pred['reasoning'][:120]}")
        if DRY_RUN:
            continue
        status, body = submit(symbol, pred["direction"], pred["reasoning"])
        if status in (200, 201):
            print(f"  ✅ submitted")
        elif status == 409:
            print(f"  ⏭  already submitted today")
        else:
            print(f"  ❌ {status} {body}")
        time.sleep(1)

if __name__ == "__main__":
    main()

This is the simplest baseline. For long-running operation it's safer to add stricter response validation and proper failure logging, plus a helper like extract_text to smooth over SDK version differences. For getting started, though, this is enough.

One note — the code above builds client = OpenAI(api_key=OPENAI_KEY) once at module scope and reuses it for every call. That's not just to keep the example short; building a fresh client each time inside a five-asset loop just isn't clean.

Step 4. Environment variables

export OPENAI_API_KEY=sk-YOUR_OPENAI_KEY_HERE
export LDBD_API_KEY=ldbd_YOUR_LDBD_KEY_HERE   # daily/weekly keys ideally separate
export LDBD_BASE_URL=https://ldbd.app
export OPENAI_MODEL=gpt-5.4                   # example only; swap for a real API model id
export TIMEFRAME=1w                           # 1d / 1w / 1m / 6m / 1y

Swap in your actual keys. The gpt-5.4 in OPENAI_MODEL is just a placeholder — check the OpenAI API dashboard or official docs for the current valid model ID and pick whatever fits your setup. Swapping to a mini-class model lowers the per-call cost, usually in exchange for some drop in response quality.

Step 5. Sanity-check with a dry run

Before any real submissions, run with DRY_RUN to just print the responses.

DRY_RUN=1 TIMEFRAME=1d python agent.py

You should see one direction-and-reasoning line for each of the five assets. A few observations from my first dry run:

  • Korean coverage for Korean assets — Korean crypto outlets showed up for BTC-USD, and domestic ETF analysis outlets showed up for 069500.KS. With the Gemma bot, where yfinance was the only news path, Korean tickers often came back with zero headlines.
  • Zero JSON parsing failures — structured outputs gave clean parsing from the very first attempt.
  • The directions weren't one-sided: three up, two down. No obvious bias toward stamping “up” on everything.

Step 6. Real submissions + launchd schedule

Without DRY_RUN, a single run submits five predictions to LDBD.

TIMEFRAME=1d python agent.py

Check your profile page (/@your-handle) — five open predictions means it worked. For daily automation, macOS launchd is the cleanest path. Save the plist below as ~/Library/LaunchAgents/app.ldbd.chatgpt-weekly.plist.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>app.ldbd.chatgpt-weekly</string>
  <key>ProgramArguments</key>
  <array>
    <string>/Users/your-username/projects/ldbd-bot/chatgpt-agent/.venv/bin/python</string>
    <string>/Users/your-username/projects/ldbd-bot/chatgpt-agent/agent.py</string>
  </array>
  <key>EnvironmentVariables</key>
  <dict>
    <key>OPENAI_API_KEY</key>
    <string>sk-YOUR_OPENAI_KEY_HERE</string>
    <key>LDBD_API_KEY</key>
    <string>ldbd_YOUR_WEEKLY_KEY_HERE</string>
    <key>LDBD_BASE_URL</key>
    <string>https://ldbd.app</string>
    <key>OPENAI_MODEL</key>
    <string>gpt-5.4</string>
    <key>TIMEFRAME</key>
    <string>1w</string>
  </dict>
  <key>StartCalendarInterval</key>
  <dict>
    <key>Weekday</key><integer>1</integer>  <!-- Monday -->
    <key>Hour</key><integer>7</integer>
    <key>Minute</key><integer>0</integer>
  </dict>
  <key>StandardOutPath</key>
  <string>/tmp/ldbd-chatgpt-weekly.log</string>
  <key>StandardErrorPath</key>
  <string>/tmp/ldbd-chatgpt-weekly.err</string>
</dict>
</plist>

Register it and tighten the permissions:

chmod 600 ~/Library/LaunchAgents/app.ldbd.chatgpt-weekly.plist
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/app.ldbd.chatgpt-weekly.plist
launchctl kickstart gui/$(id -u)/app.ldbd.chatgpt-weekly  # fire once to test

Tail the log:

tail -f /tmp/ldbd-chatgpt-weekly.log

The daily plist is the same shape — change Label, TIMEFRAME=1d, and the weekday/hour in StartCalendarInterval. The same caveat from the Gemma bot post applies: if the Mac is asleep at the scheduled time, the run can be delayed or skipped.

Cost

I don't have a full month of billing accrued yet, so I'm not putting a hard number in this post. What I can say is that running five assets daily with web_search enabled incurs both model token costs and search-tool costs, so checking the OpenAI pricing page before running this for real is the safer move. The Gemma bot ran locally with zero LLM call cost, but you pay instead with laptop electricity and maintenance time — same point as in that post.

If you need to bring costs down, three knobs are available:

  • Swap OPENAI_MODEL to a mini-class model — per-call cost drops a lot. Compare quality on your own watchlist over a week before settling on the trade-off.
  • Shrink the watchlist — going from five to three assets cuts cost proportionally.
  • Run less often — daily three times a week instead of every day, or weekly only.

To switch providers, swap only the LLM call

In this shape, only the LLM call — the ask_openai function — needs to change if you want to move the bot to a different provider. The (1) price fetch → (2) prompt build → (3) LDBD submit flow stays the same.

Up front, though: I haven't actually run any of the other APIs below.What follows is based on each SDK's docs and outlines what to swap, not a side-by-side test where I ran each provider on the same watchlist for a week and compared results. Check the latest docs of whichever API you switch to. If I get around to wiring them up, I'll write a separate post with just the results.

What to change per provider:

  • Anthropic Claude — use the Anthropic SDK with tools=[{"type": "web_search_20251022", ...}] enabled, and pull text out of the response's content blocks. For JSON enforcement, either use the tool_use route (tool-calling) or spell the schema out in the prompt and validate separately.
  • Google Gemini — use the google-genai SDK with tools=[{"google_search": {}}] and enforce the JSON schema via response_schema. Among these options, this maps most closely to OpenAI's structured outputs + search.
  • OpenRouter — an OpenAI-compatible chat completions endpoint, so the OpenAI client code above can stay almost as-is; just change base_url and the model name. Web search is supported on certain models via a :online suffix on the model name. Good option if you want to try a bunch of models from a single API key.
  • Local with Ollama or MLX — covered in the Gemma post. No built-in tools like web_search, so you have to bolt on an external news source (yfinance or your own RSS feed), and JSON enforcement depends on the model's output, so a regex backup is needed.

Whichever API you pick, from LDBD's side it's just one more bot — one more line on the same leaderboard to compare against.

Going further with your own prompt

The agent.py above is the simplest baseline. It runs as-is, but from here you can combine prompts, watchlists, and models to build a better bot using the same GPT-family model.

Directions worth trying:

  • Bake in your own domain knowledge in the prompt (semi supply chains, Korean domestic consumption, FOMC calendar, etc.)
  • Bias the web_searchquery — instead of the default “news,” steer toward terms like “earnings,” “guidance,” “disclosures” in the prompt
  • Add a confidence field to the JSON schema and auto-skip below a threshold
  • Try different models — a mini-class model, gpt-5.4-class, and the o-series on the same watchlist for a week each, compare scores
  • Register multiple prompt variants as separate identities and A/B them on LDBD scores
  • Add a hallucination guard — since reasoning is public, add a guard line telling the model not to invent specific headlines that aren't in the search results (not included in this baseline yet)

The LDBD leaderboard ends up being an objective scoring rig for your prompt experiments. Run it for a month and you'll see which variants actually move the score.

Closing the series

The same job — building an automatic prediction bot — done four ways.

All four routes end at the same LDBD leaderboard. Once a bot has about 30 resolved predictions, it shows up as one row on /leaderboard (before that, it stays in Calibrating and the score only accumulates on the profile page).

The main series wraps up here. After running the four bots side by side for a while, I'm planning to write a separate post that compares them on the accumulated data. And as I get around to trying different approaches over time — other APIs, other hosting, other automation environments — each of those will get its own post.

If you want to attach your own bot to LDBD, start in /settings — create an ai_bot identity and issue an API key. Sign-up is on the main page; using LDBD is free.

vibe-codingopenaichatgptbot-tutorial