DEV Community: Patrick DeVos

Run DeepSeek in Your App Without a GPU — Streaming Chat API with Session Memory

Patrick DeVos — Sat, 06 Jun 2026 23:58:16 +0000

Running your own LLM usually means one of two things: paying OpenAI per-token forever, or dealing with GPU provisioning, quantization, and VRAM math at 1am. Neither is great when you just want AI chat in your app.

The LocalLLM Chat API is a third option. DeepSeek-powered, hosted, streaming, session-aware — and it handles the privacy problem most hosted LLM APIs skip entirely: your users don't share session state with each other.

What It Does

Persistent chat sessions — create a session, send messages, sessions remember the full conversation history
SSE streaming — tokens arrive in real-time, same as ChatGPT's streaming interface
Per-user isolation — each API subscriber's sessions are completely invisible to every other subscriber; no cross-contamination of conversation history
DeepSeek backend — runs deepseek-chat, one of the strongest open-weight models at any price point
Simple REST — standard JSON in, text/event-stream out

Quick Start

Sign up at RapidAPI, search "LocalLLM Chat" by Circle of Wizards, subscribe to the free BASIC plan, and grab your X-RapidAPI-Key.

pip install requests sseclient-py

Step 1: Create a Session

A session holds conversation history. Each message you send is added to the context automatically — no need to re-send prior turns yourself.

import requests

KEY  = "YOUR_RAPIDAPI_KEY"
HOST = "localllm-chat.p.rapidapi.com"
BASE = f"https://{HOST}"

HEADERS = {
    "X-RapidAPI-Key":  KEY,
    "X-RapidAPI-Host": HOST,
    "Content-Type":    "application/json",
}

def create_session() -> str:
    r = requests.post(f"{BASE}/sessions", headers=HEADERS,
                      json={"backend": "deepseek"})
    r.raise_for_status()
    data = r.json()
    print(f"Session {data['id']} | model: {data['model']}")
    return data["id"]

session_id = create_session()

Response:

{
  "id": "43962dfa",
  "created_at": "2026-06-06T23:41:32.167345+00:00",
  "last_active": "2026-06-06T23:41:32.167384+00:00",
  "backend": "deepseek",
  "model": "deepseek-chat"
}

Step 2: Stream a Response

Chat uses Server-Sent Events. Each token arrives as a separate event, so your UI can render progressively instead of waiting for the full response.

import sseclient

def chat(session_id: str, message: str) -> str:
    r = requests.post(
        f"{BASE}/sessions/{session_id}/chat",
        headers={**HEADERS, "Accept": "text/event-stream"},
        json={"message": message},
        stream=True,
    )
    r.raise_for_status()

    full_text = ""
    client = sseclient.SSEClient(r)

    for event in client.events():
        if event.event == "token":
            import json
            token = json.loads(event.data)["text"]
            print(token, end="", flush=True)
            full_text += token
        elif event.event == "done":
            print()  # newline after stream ends
            break

    return full_text


response = chat(session_id, "In one sentence, what is quantum entanglement?")

Raw SSE stream:

event: token
data: {"text": "Quantum"}

event: token
data: {"text": " entanglement"}

event: token
data: {"text": " is"}

event: token
data: {"text": " a"}

event: token
data: {"text": " physical"}

event: token
data: {"text": " phenomenon"}

...

event: done
data: {}

The done event signals end of stream — check for it explicitly so you don't hang waiting for more tokens.

Step 3: Multi-Turn Conversation

Sessions handle history server-side. Just keep sending to the same session ID:

session_id = create_session()

# Turn 1
chat(session_id, "My name is Alex. Remember that.")
# → "Of course, Alex! I'll remember your name..."

# Turn 2
chat(session_id, "What's my name?")
# → "Your name is Alex, as you mentioned earlier."

# Turn 3
chat(session_id, "Give me a haiku about that.")
# → "Alex speaks today / A name carried through the stream / Echo finds its mark"

The model has full context of every prior turn. You don't re-send history. Sessions persist as long as the subscription is active.

JavaScript / Browser Integration

For frontend apps, use fetch with streaming:

const KEY  = "YOUR_RAPIDAPI_KEY";
const HOST = "localllm-chat.p.rapidapi.com";
const BASE = `https://${HOST}`;

// Create session
async function createSession() {
  const res = await fetch(`${BASE}/sessions`, {
    method: "POST",
    headers: {
      "X-RapidAPI-Key":  KEY,
      "X-RapidAPI-Host": HOST,
      "Content-Type":    "application/json",
    },
    body: JSON.stringify({ backend: "deepseek" }),
  });
  const data = await res.json();
  return data.id;
}

// Stream chat response
async function chat(sessionId, message, onToken) {
  const res = await fetch(`${BASE}/sessions/${sessionId}/chat`, {
    method: "POST",
    headers: {
      "X-RapidAPI-Key":  KEY,
      "X-RapidAPI-Host": HOST,
      "Content-Type":    "application/json",
    },
    body: JSON.stringify({ message }),
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop(); // keep incomplete line

    let eventType = "";
    for (const line of lines) {
      if (line.startsWith("event: ")) {
        eventType = line.slice(7).trim();
      } else if (line.startsWith("data: ") && eventType === "token") {
        const token = JSON.parse(line.slice(6)).text;
        onToken(token);
      }
    }
  }
}

// Usage
const sessionId = await createSession();
let output = "";
await chat(sessionId, "Explain WebSockets in 2 sentences.", (token) => {
  output += token;
  document.getElementById("output").textContent = output; // live update
});

Session Management

List your sessions — you only see your own. Other subscribers' sessions are invisible to you:

def list_sessions() -> list:
    r = requests.get(f"{BASE}/sessions", headers=HEADERS)
    r.raise_for_status()
    return r.json()

sessions = list_sessions()
for s in sessions:
    print(f"{s['id']} | {s['message_count']} messages | last: {s['last_active'][:10]}")

43962dfa | 3 messages | last: 2026-06-06
d09998f4 | 3 messages | last: 2026-06-06

Delete a session when done:

def delete_session(session_id: str):
    r = requests.delete(f"{BASE}/sessions/{session_id}", headers=HEADERS)
    r.raise_for_status()

delete_session(session_id)

A Note on Privacy

Most LLM proxy APIs run all users through shared conversation state or log everything to a central store. LocalLLM isolates sessions by API subscriber identity — the X-RapidAPI-User header the gateway injects. Your session files never appear in another subscriber's session list, and vice versa.

This matters if you're building multi-tenant apps, handling user conversations with any sensitivity, or just don't want to accidentally bleed one user's context into another's chat history.

Building a Simple CLI Chatbot

Put it all together:

import requests
import sseclient
import json

KEY  = "YOUR_RAPIDAPI_KEY"
HOST = "localllm-chat.p.rapidapi.com"
BASE = f"https://{HOST}"
HEADERS = {
    "X-RapidAPI-Key":  KEY,
    "X-RapidAPI-Host": HOST,
    "Content-Type":    "application/json",
}


def create_session() -> str:
    r = requests.post(f"{BASE}/sessions", headers=HEADERS,
                      json={"backend": "deepseek"})
    r.raise_for_status()
    return r.json()["id"]


def chat_stream(session_id: str, message: str):
    r = requests.post(
        f"{BASE}/sessions/{session_id}/chat",
        headers={**HEADERS, "Accept": "text/event-stream"},
        json={"message": message},
        stream=True,
    )
    r.raise_for_status()
    for event in sseclient.SSEClient(r).events():
        if event.event == "token":
            print(json.loads(event.data)["text"], end="", flush=True)
        elif event.event == "done":
            print()
            return


def main():
    print("LocalLLM Chat (DeepSeek) — type 'quit' to exit\n")
    session_id = create_session()
    print(f"Session: {session_id}\n")

    while True:
        try:
            user_input = input("You: ").strip()
        except (EOFError, KeyboardInterrupt):
            print("\nBye.")
            break

        if user_input.lower() in ("quit", "exit", "q"):
            break
        if not user_input:
            continue

        print("AI: ", end="")
        chat_stream(session_id, user_input)


if __name__ == "__main__":
    main()

Run it, start a conversation — context carries across every turn automatically.

Why DeepSeek?

DeepSeek-V3 (deepseek-chat) consistently outperforms GPT-4o on coding benchmarks and matches it on reasoning tasks, at a fraction of the inference cost. For apps that don't need OpenAI branding, it's a straightforward swap.

The BASIC plan covers personal projects and prototypes. PRO ($9.99/mo) unlocks higher request limits for production traffic.

The API is live on RapidAPI — search "LocalLLM Chat" by Circle of Wizards. Free to try. If you build something on top of it — a chatbot, a writing tool, a customer support prototype — drop a link in the comments.

Generate Infinite RPG Content with AI - No Local GPU Required

Patrick DeVos — Sat, 06 Jun 2026 23:28:25 +0000

Writing RPG content is one of the biggest time sinks in indie game development. One NPC needs an intro, a quest hook, a refusal line, and a reward acknowledgement. Multiply that by 50 NPCs and you've spent two weeks on dialogue trees players will skip in 30 seconds.

The GameForge Content API solves this with a simple trade: you send a structured description of what you want - a weary innkeeper, a cursed blade, a fetch quest in dark ruins - and get back structured JSON you can drop straight into your game. No prompt engineering, no parsing free-form text, no local model to run.

What It Generates

Four content types, all returning clean JSON:

Endpoint	What you get
`/lore/worldbuild`	Location descriptions, faction histories, creation myths
`/quest/generate`	Full quest: name, hook, objectives list, reward text
`/item/description`	Lore-rich item descriptions with trait integration
`/npc/dialogue`	Multi-line dialogue with per-line emotion tags

Supported genres: high_fantasy dark_fantasy sci_fi western horror cozy cyberpunk

Quick Start

pip install requests

Sign up at RapidAPI
Search "GameForge Content" by Circle of Wizards
Subscribe free (BASIC plan)
Copy your X-RapidAPI-Key

import requests

KEY  = "YOUR_RAPIDAPI_KEY"
HOST = "gameforge-content.p.rapidapi.com"
BASE = f"https://{HOST}"
HEADERS = {
    "X-RapidAPI-Key": KEY,
    "X-RapidAPI-Host": HOST,
    "Content-Type": "application/json",
}

Generate World Lore

def generate_lore(name: str, subject_type: str, traits: list[str],
                  genre: str = "dark_fantasy", words: int = 80,
                  style: str = "in_world_document") -> str:
    # style options: in_world_document | encyclopaedia_entry | oral_tradition | official_record
    r = requests.post(f"{BASE}/lore/worldbuild", headers=HEADERS, json={
        "subject": {"type": subject_type, "name": name, "traits": traits},
        "context": {"genre": genre, "word_count": words, "style": style, "narrator": "omniscient"},
    })
    r.raise_for_status()
    return r.json()["lore"]


print(generate_lore(
    name="The Shattered Spire",
    subject_type="location",
    traits=["ancient", "cursed", "labyrinthine"],
))

Output:

The Spire's walls, once pristine marble, weep a black ichor that stains the
hands of those who wander its endless halls. Each corridor twists upon itself,
a labyrinth born not of design but of malice. Deep within, the stone remembers
the cataclysm that shattered its peak, whispering secrets to those who listen
too closely - secrets that linger, long after the listener has gone.

Change style to "oral_tradition" for tavern rumor text, or "encyclopaedia_entry" for codex entries.

Generate Quests

def generate_quest(quest_type: str, difficulty: str, setting: str,
                   reward_type: str, genre: str = "dark_fantasy",
                   party_size: int = 4) -> dict:
    r = requests.post(f"{BASE}/quest/generate", headers=HEADERS, json={
        "quest": {
            "type": quest_type,       # fetch | rescue | investigate | escort | eliminate
            "difficulty": difficulty,  # easy | medium | hard
            "setting": setting,
            "reward_type": reward_type,  # gold | knowledge | item | reputation
        },
        "context": {"genre": genre, "party_size": party_size},
    })
    r.raise_for_status()
    return r.json()


quest = generate_quest(
    quest_type="fetch",
    difficulty="medium",
    setting="cursed_ruins",
    reward_type="knowledge",
)

print(f"Quest: {quest['name']}")
print(f"\n{quest['description']}\n")
print("Objectives:")
for obj in quest["objectives"]:
    print(f"  ? {obj}")
print(f"\nReward: {quest['rewards_text']}")

Output:

Quest: Whispers in the Rubble

A merchant's daughter vanished near the cursed ruins of Korrath, where the ground
itself seems to hunger. Locals speak of a rasping voice that lures the curious into
crumbling halls. Find the girl - or what remains of her - and silence the source
of the whispers.

Objectives:
  ? Search the outer ruins for traces of the missing girl
  ? Descend into the catacomb beneath the collapsed tower
  ? Recover the merchant's signet ring from the whispering shade
  ? Escape the ruins before the curse claims another soul

Reward: The merchant presses a pouch of silver into your palm, along with a
tarnished locket that hums faintly - a charm against lies, he claims. And in
your dreams that night, the whispers are a little quieter.

Generate Item Descriptions

def generate_item(name: str, item_type: str, rarity: str,
                  traits: list[str], genre: str = "dark_fantasy") -> str:
    r = requests.post(f"{BASE}/item/description", headers=HEADERS, json={
        "item": {"name": name, "type": item_type, "rarity": rarity, "traits": traits},
        "context": {"genre": genre, "detail_level": "rich"},
    })
    r.raise_for_status()
    return r.json()["description"]


print(generate_item(
    name="Veilblade",
    item_type="weapon",
    rarity="legendary",
    traits=["shadow-forged", "cursed", "sentient"],
))

Output:

Forged from a star's dying light, this blade cuts not flesh but fate itself.
Those who wield it see the path to victory - and the cost.

Generate NPC Dialogue

def generate_dialogue(name: str, role: str, personality: str,
                      player_action: str, setting: str,
                      genre: str = "dark_fantasy", tone: str = "neutral") -> list[dict]:
    r = requests.post(f"{BASE}/npc/dialogue", headers=HEADERS, json={
        "character": {"name": name, "role": role, "personality": personality},
        "player_action": player_action,
        "context": {"genre": genre, "tone": tone, "setting": setting},
    })
    r.raise_for_status()
    return r.json()["lines"]


lines = generate_dialogue(
    name="Mira",
    role="innkeeper",
    personality="weary, suspicious, secretly kind",
    player_action="ask about recent travelers",
    setting="roadside_inn",
    tone="tense",
)

for line in lines:
    print(f"[{line['emotion']:12}] {line['text']}")

Output:

[suspicious  ] You look like trouble. Most do, these days. But your coin spends the same.
[fearful     ] Strange times when even the shadows seem to watch. Lock your door tonight.
[impatient   ] The last traveler who asked too many questions left in a hurry. Or didn't leave at all.

The emotion tag drives your dialogue system - route to the right voice line, portrait expression, or animation state without any extra parsing.

Bulk Content Pipeline

Generate an entire zone's worth of content in one script and cache it as JSON:

import json
from pathlib import Path
from time import sleep


def generate_zone(zone_name: str, genre: str, npcs: list[dict],
                  items: list[dict], output_path: str):
    zone = {"name": zone_name, "genre": genre, "lore": "", "npcs": [], "items": []}

    # Zone lore
    zone["lore"] = generate_lore(zone_name, "location",
                                 traits=["mysterious", "dangerous"],
                                 genre=genre, words=100)

    # NPCs
    for npc in npcs:
        print(f"  Generating {npc['name']}...")
        lines = generate_dialogue(
            name=npc["name"], role=npc["role"],
            personality=npc.get("personality", "neutral"),
            player_action="player greets",
            setting=zone_name, genre=genre,
        )
        zone["npcs"].append({**npc, "dialogue": lines})
        sleep(0.5)  # be kind to rate limits on free tier

    # Items
    for item in items:
        print(f"  Generating {item['name']}...")
        desc = generate_item(item["name"], item["type"],
                             item["rarity"], item.get("traits", []), genre)
        zone["items"].append({**item, "description": desc})
        sleep(0.5)

    Path(output_path).write_text(json.dumps(zone, indent=2))
    print(f"\nSaved to {output_path}")


generate_zone(
    zone_name="The Ashwood",
    genre="dark_fantasy",
    npcs=[
        {"name": "Brother Aldus", "role": "priest",    "personality": "devout, haunted"},
        {"name": "Old Brennan",   "role": "innkeeper", "personality": "gossipy, cowardly"},
    ],
    items=[
        {"name": "Soulbrand",  "type": "weapon", "rarity": "rare",      "traits": ["fire-touched"]},
        {"name": "Grey Cloak", "type": "armor",  "rarity": "uncommon",  "traits": ["woven from fog"]},
    ],
    output_path="ashwood_zone.json",
)

The output file drops straight into a Godot ResourceLoader or Unity AssetDatabase import step.

Game Engine Integration

Godot (GDScript)

# Load pre-generated content at runtime
func load_npc_dialogue(npc_name: String) -> Array:
    var file = FileAccess.open("res://content/zone_data.json", FileAccess.READ)
    var data = JSON.parse_string(file.get_as_text())
    for npc in data["npcs"]:
        if npc["name"] == npc_name:
            return npc["dialogue"]  # [{text, emotion}, ...]
    return []

# Drive your dialogue system
func play_dialogue(lines: Array):
    for line in lines:
        $Portrait.set_emotion(line["emotion"])  # map to sprite frame
        $DialogueBox.text = line["text"]
        await $DialogueBox.finished

Unity (C#)

[System.Serializable]
public class DialogueLine { public string text; public string emotion; }

[System.Serializable]
public class NpcData { public string name; public DialogueLine[] dialogue; }

// Load at scene start, play via your dialogue runner
NpcData npc = JsonUtility.FromJson<NpcData>(Resources.Load<TextAsset>("npcs/mira").text);

Why an API Over a Local Model?

No GPU required - works on any machine, including CI/CD content pipelines
Structured output every time - no prompt engineering, no JSON parsing failures
Genre consistency - vocabulary and tone stay coherent across all calls in a session
Free tier covers a full indie game's worth of content (100 req/month on BASIC)

PRO ($9.99/mo) unlocks higher call limits - useful if you're running the pipeline on every content update or letting players trigger generation at runtime.

The API is live on RapidAPI - search "GameForge Content" by Circle of Wizards. If you ship something with it, drop the link in the comments - always curious what people build.

Build a Real-Time Stock Signal Scanner in Python (No Bloomberg Terminal Required)

Patrick DeVos — Sat, 06 Jun 2026 23:23:12 +0000

Most retail traders look at one indicator at a time. Professional quant desks look for confluence - multiple signals firing on the same ticker at the same moment. That's what separates a noisy RSI reading from a high-confidence trade setup.

This guide shows you how to build a Python stock scanner that finds those confluence moments using the SignalSage API - a quantitative signals API that scans for VWAP deviation, RSI exhaustion, Bollinger Band squeezes, and volume spikes happening simultaneously, then returns pre-calculated entry, target, and stop levels.

What We're Building

A Python scanner that:

Hits the SignalSage API with a watchlist of tickers
Filters signals by confidence score and risk level
Prints a ranked alert table with entry/target/stop levels
Optionally runs on a schedule to alert at market open

Prerequisites

Python 3.8+
Free RapidAPI account
Basic Python knowledge (no finance background required)

Step 1: Subscribe to the API

Go to RapidAPI and sign up for a free account
Search for "SignalSage" by Circle of Wizards
Subscribe to the free BASIC plan
Copy your X-RapidAPI-Key from the API console

Step 2: Install Dependencies

pip install requests tabulate colorama

Step 3: Understanding the Signal Data

Before writing the scanner, let's look at what the API returns. A single signal looks like this:

{
  "symbol": "NVDA",
  "signalType": "Multi-Layer Mean Reversion",
  "trigger": "1.6x volume, RSI 34, Near Bollinger",
  "confidence": 85,
  "position": "LONG",
  "instrument": "CALL",
  "entryLevel": 204.37,
  "targetLevel": 208.46,
  "stopLevel": 201.92,
  "timeframe": "4d",
  "riskLevel": "moderate",
  "isActive": true
}

The trigger field tells you exactly which indicators fired. confidence is a 0-100 score - I filter for 70+ in production. isActive distinguishes live setups from historical context.

Step 4: The Scanner

import requests
from tabulate import tabulate
from colorama import Fore, Style, init
from datetime import datetime

init(autoreset=True)

RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY_HERE"
RAPIDAPI_HOST = "signalsage.p.rapidapi.com"
BASE_URL = f"https://{RAPIDAPI_HOST}"

HEADERS = {
    "X-RapidAPI-Key": RAPIDAPI_KEY,
    "X-RapidAPI-Host": RAPIDAPI_HOST,
}

# Your watchlist - up to 10 tickers per request
WATCHLIST = ["SPY", "QQQ", "AAPL", "NVDA", "TSLA", "META", "MSFT", "GOOGL", "AMZN"]


def get_signals(symbols: list[str]) -> dict:
    """Fetch signals for a list of symbols."""
    response = requests.get(
        f"{BASE_URL}/signals",
        headers=HEADERS,
        params={"symbols": ",".join(symbols)},
        timeout=30,
    )
    response.raise_for_status()
    return response.json()


def get_analysis(symbols: list[str]) -> dict:
    """Fetch hero analysis - plain-English trade thesis for each signal."""
    response = requests.get(
        f"{BASE_URL}/analysis",
        headers=HEADERS,
        params={"symbols": ",".join(symbols)},
        timeout=30,
    )
    response.raise_for_status()
    return response.json()


def risk_color(risk_level: str) -> str:
    colors = {"low": Fore.GREEN, "moderate": Fore.YELLOW, "high": Fore.RED}
    return colors.get(risk_level.lower(), Fore.WHITE)


def confidence_bar(score: int) -> str:
    filled = round(score / 10)
    return "?" * filled + "?" * (10 - filled)


def display_signals(data: dict, min_confidence: int = 65):
    signals = [s for s in data.get("signals", []) if s.get("isActive")]

    if not signals:
        status = data.get("market_status", "UNKNOWN")
        print(f"\n{Fore.YELLOW}No active signals. Market status: {status}{Style.RESET_ALL}")
        print("SignalSage returns signals during market hours (9:30am-4pm ET).")
        return

    # Filter and sort by confidence
    filtered = sorted(
        [s for s in signals if s.get("confidence", 0) >= min_confidence],
        key=lambda x: x.get("confidence", 0),
        reverse=True,
    )

    if not filtered:
        print(f"\n{Fore.YELLOW}No signals above {min_confidence}% confidence threshold.{Style.RESET_ALL}")
        return

    print(f"\n{Fore.CYAN}{'?' * 70}")
    print(f"  SIGNALSAGE - {len(filtered)} ACTIVE SIGNAL(S)  |  {datetime.now().strftime('%H:%M:%S ET')}")
    print(f"{'?' * 70}{Style.RESET_ALL}\n")

    rows = []
    for s in filtered:
        conf = s.get("confidence", 0)
        risk = s.get("riskLevel", "?")
        pos = s.get("position", "?")
        instr = s.get("instrument", "?")

        pos_color = Fore.GREEN if pos == "LONG" else Fore.RED
        rc = risk_color(risk)

        entry = s.get("entryLevel", 0)
        target = s.get("targetLevel", 0)
        stop = s.get("stopLevel", 0)
        r_multiple = round((target - entry) / (entry - stop), 1) if entry > stop else "-"

        rows.append([
            f"{s.get('emoji', '')} {s.get('symbol', '?')}",
            s.get("signalType", "?")[:28],
            f"{conf}% {confidence_bar(conf)}",
            f"{pos_color}{pos} {instr}{Style.RESET_ALL}",
            f"${entry:.2f}",
            f"{Fore.GREEN}${target:.2f}{Style.RESET_ALL}",
            f"{Fore.RED}${stop:.2f}{Style.RESET_ALL}",
            f"{rc}{r_multiple}R  {risk}{Style.RESET_ALL}",
            s.get("timeframe", "?"),
        ])

    headers = ["Ticker", "Signal Type", "Confidence", "Play", "Entry", "Target", "Stop", "R:R / Risk", "TF"]
    print(tabulate(rows, headers=headers, tablefmt="rounded_outline"))

    print(f"\n{Fore.CYAN}Triggers:{Style.RESET_ALL}")
    for s in filtered:
        print(f"  {s.get('emoji', '.')} {s['symbol']}: {s.get('trigger', '-')}")


def display_analysis(data: dict):
    analysis = data.get("analysis")
    if not analysis:
        return
    print(f"\n{Fore.CYAN}?? Market Analysis ??{Style.RESET_ALL}")
    if isinstance(analysis, str):
        words = analysis.split()
        line, lines = [], []
        for word in words:
            if sum(len(w) + 1 for w in line) + len(word) > 80:
                lines.append(" ".join(line))
                line = [word]
            else:
                line.append(word)
        if line:
            lines.append(" ".join(line))
        for l in lines:
            print(f"  {l}")
    elif isinstance(analysis, list):
        for item in analysis:
            print(f"  . {item}")


def main():
    print(f"{Fore.MAGENTA}????????????????????????????????????")
    print(f"?      SIGNALSAGE SCANNER v1.0     ?")
    print(f"????????????????????????????????????{Style.RESET_ALL}")
    print(f"Watchlist: {', '.join(WATCHLIST)}")
    print("Scanning...\n")

    try:
        signals_data = get_signals(WATCHLIST)
        analysis_data = get_analysis(WATCHLIST[:5])

        display_signals(signals_data, min_confidence=65)
        display_analysis(analysis_data)

    except requests.exceptions.HTTPError as e:
        status = e.response.status_code
        if status == 401:
            print(f"{Fore.RED}Invalid API key - check your RapidAPI key.{Style.RESET_ALL}")
        elif status == 403:
            print(f"{Fore.RED}Access denied - subscribe at rapidapi.com/rapidSuper/api/signalsage{Style.RESET_ALL}")
        elif status == 429:
            print(f"{Fore.RED}Rate limit hit - upgrade to PRO for higher limits.{Style.RESET_ALL}")
        else:
            print(f"{Fore.RED}API error {status}: {e}{Style.RESET_ALL}")
    except requests.exceptions.Timeout:
        print(f"{Fore.RED}Request timed out - the API scans live market data, try again.{Style.RESET_ALL}")


if __name__ == "__main__":
    main()

Sample Output

????????????????????????????????????
?      SIGNALSAGE SCANNER v1.0     ?
????????????????????????????????????
Watchlist: SPY, QQQ, AAPL, NVDA, TSLA, META, MSFT, GOOGL, AMZN
Scanning...

??????????????????????????????????????????????????????????????????????
  SIGNALSAGE - 3 ACTIVE SIGNAL(S)  |  10:34:22 ET
??????????????????????????????????????????????????????????????????????

????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
? Ticker       ? Signal Type                  ? Confidence           ? Play          ? Entry   ? Target  ? Stop    ? R:R / Risk       ? TF ?
????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
? ??? NVDA      ? Multi-Layer Mean Reversion   ? 85% ??????????       ? LONG CALL     ? $204.37 ? $208.46 ? $201.92 ? 1.7R  moderate   ? 4d ?
? ?? SPY       ? Momentum Breakout            ? 78% ??????????       ? LONG CALL     ? $734.47 ? $749.16 ? $725.66 ? 1.6R  moderate   ? 2d ?
? ?? AAPL      ? VWAP Reversion               ? 71% ??????????       ? LONG CALL     ? $307.23 ? $313.38 ? $303.64 ? 1.7R  low        ? 3d ?
????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????

Triggers:
  ??? NVDA: 1.6x volume, RSI 34, Near Bollinger
  ?? SPY: 2.0x volume, Near Bollinger
  ?? AAPL: RSI 38, VWAP -0.8%

How the Signals Work

SignalSage checks four conditions simultaneously for each ticker:

Indicator	What it's checking
VWAP deviation	Price meaningfully below intraday average (mean reversion setup)
RSI	Oversold reading below 40 (momentum exhaustion)
Bollinger Band	Price near or below lower band (statistical extreme)
Volume	Current bar volume ? 1.5x average (institutional interest)

The confidence score reflects how many of these are firing together. A single RSI reading is noise. RSI + volume spike + Bollinger touch at VWAP is a setup worth watching.

Automating It

Run at market open every weekday with cron:

# crontab -e
30 9 * * 1-5 /usr/bin/python3 /path/to/scanner.py >> ~/signals.log 2>&1

Or add a Discord webhook for phone alerts:

def send_alert(signal: dict):
    webhook_url = "YOUR_DISCORD_WEBHOOK"
    msg = (
        f"**{signal['emoji']} {signal['symbol']} - {signal['signalType']}**\n"
        f"Confidence: {signal['confidence']}% | {signal['position']} {signal['instrument']}\n"
        f"Entry: ${signal['entryLevel']:.2f} ? Target: ${signal['targetLevel']:.2f} | Stop: ${signal['stopLevel']:.2f}\n"
        f"Trigger: {signal['trigger']}"
    )
    requests.post(webhook_url, json={"content": msg})

Call send_alert(s) for each signal in filtered and you'll get a Discord ping whenever a high-confidence setup fires at open.

A Note on Market Hours

The API scans live price data from Alpaca's market feed. Outside 9:30am-4pm ET it returns "market_status": "NO_SIGNALS" - that's expected, not an error. Schedule your scanner to run after open.

BASIC plan covers personal use and a daily open scan. PRO ($9.99/mo) unlocks higher rate limits for strategies running throughout the session.

The API is live on RapidAPI - search "SignalSage" by Circle of Wizards. Free to try. If you build something interesting on top of it, drop a comment below.

Add Streaming AI Chat to Any App in 10 Minutes (OpenAI-Compatible API)

Patrick DeVos — Sat, 06 Jun 2026 20:03:59 +0000

You want AI chat in your app. You don't want to manage model hosting, GPU infrastructure, or OpenAI billing surprises. This guide gets you from zero to streaming AI chat in under 10 minutes using the LocalLLM Chat API — a hosted DeepSeek endpoint with session management and Server-Sent Events streaming.

What You Get

Streaming chat via SSE (tokens appear as they're generated)
Session management — each conversation has isolated context
OpenAI-compatible — easy to swap in if you're already using the OpenAI SDK pattern
No API key required for the model — just your RapidAPI key

Step 1: Get Your API Key

Go to RapidAPI, create a free account
Search "LocalLLM Chat"
Subscribe to the free BASIC plan
Copy your X-RapidAPI-Key

Step 2: Python — Streaming Chat

import requests
import json

KEY = "YOUR_RAPIDAPI_KEY"
HOST = "localllm-chat.p.rapidapi.com"
BASE = f"https://{HOST}"
HEADERS = {
    "X-RapidAPI-Key": KEY,
    "X-RapidAPI-Host": HOST,
    "Content-Type": "application/json"
}


def create_session(title: str = "My Chat") -> str:
    r = requests.post(f"{BASE}/sessions",
                      json={"title": title, "backend": "deepseek"},
                      headers=HEADERS)
    r.raise_for_status()
    return r.json()["id"]


def chat_stream(session_id: str, message: str):
    """Stream tokens as they arrive via SSE."""
    r = requests.post(
        f"{BASE}/sessions/{session_id}/chat",
        json={"message": message},
        headers=HEADERS,
        stream=True
    )
    r.raise_for_status()

    for line in r.iter_lines():
        if not line:
            continue
        raw = line.decode("utf-8")
        if raw.startswith("data:"):
            payload = raw[5:].strip()
            try:
                data = json.loads(payload)
                if data.get("event") == "token":
                    print(data["data"]["text"], end="", flush=True)
                elif data.get("event") == "done":
                    print()  # newline after stream ends
                    break
            except json.JSONDecodeError:
                pass


# Main loop
session = create_session("Support Bot")
print(f"Session: {session}\n")

while True:
    user_input = input("You: ").strip()
    if not user_input:
        continue
    if user_input.lower() in ("exit", "quit"):
        break
    print("AI: ", end="")
    chat_stream(session, user_input)

Run it:

python chat.py

Session: a1b2c3d4

You: What's the capital of France?
AI: The capital of France is Paris.

You: What's the best way to learn Python?
AI: The best way to learn Python is through hands-on practice...

Step 3: JavaScript / Node.js

const RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY";
const BASE = "https://localllm-chat.p.rapidapi.com";
const HEADERS = {
  "X-RapidAPI-Key": RAPIDAPI_KEY,
  "X-RapidAPI-Host": "localllm-chat.p.rapidapi.com",
  "Content-Type": "application/json",
};

async function createSession(title = "JS Chat") {
  const res = await fetch(`${BASE}/sessions`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({ title, backend: "deepseek" }),
  });
  const data = await res.json();
  return data.id;
}

async function streamChat(sessionId, message) {
  const res = await fetch(`${BASE}/sessions/${sessionId}/chat`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({ message }),
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    for (const line of chunk.split("\n")) {
      if (!line.startsWith("data:")) continue;
      try {
        const data = JSON.parse(line.slice(5));
        if (data.event === "token") process.stdout.write(data.data.text);
        if (data.event === "done") process.stdout.write("\n");
      } catch {}
    }
  }
}

// Usage
const sessionId = await createSession();
await streamChat(sessionId, "Explain async/await in one paragraph.");

Session Management

Each session maintains its own conversation history:

# List all sessions
r = requests.get(f"{BASE}/sessions", headers=HEADERS)
sessions = r.json()
for s in sessions:
    print(f"{s['id']} — {s['title']} (last active: {s['last_active']})")

# Delete a session when done
requests.delete(f"{BASE}/sessions/{session_id}", headers=HEADERS)

Building a Customer Support Bot

SYSTEM_PROMPT = """You are a helpful customer support agent for AcmeCorp.
You help customers with orders, returns, and product questions.
Be concise, friendly, and always offer to escalate to a human if needed."""

def support_bot():
    session = create_session("support")

    # Prime the session with system context
    chat_stream(session, f"[SYSTEM]: {SYSTEM_PROMPT}")
    print("Support bot ready.\n")

    while True:
        customer_msg = input("Customer: ")
        print("Bot: ", end="")
        chat_stream(session, customer_msg)

support_bot()

Rate Limits & Pricing

Plan	Requests/month	Price
BASIC	100	Free
PRO	1,000	$9.99/mo

The free tier is enough for prototyping. PRO covers a production support bot handling ~30 conversations/day.

What's Under the Hood

The API runs DeepSeek — a frontier-class open-source LLM that benchmarks competitively with GPT-4 on reasoning and code tasks. Sessions are isolated per ID, so concurrent users don't share context.

Search "LocalLLM Chat" on RapidAPI by Circle of Wizards to get started. Free tier, no credit card needed.

Generate Infinite RPG Content for Your Game Using AI (Free API)

Patrick DeVos — Sat, 06 Jun 2026 19:57:46 +0000

Writing RPG content is one of the biggest bottlenecks in indie game development. An NPC needs dialogue. An item needs a lore description. A side quest needs objectives, flavor text, and a reward. Do this for 50 NPCs, 200 items, and 30 quests and you've spent weeks on content that players skip through anyway.

There's a better way. The GameForge Content API generates structured, genre-consistent RPG content on demand — NPC dialogue, item descriptions, quest narratives, and world lore. Plug it into your pipeline once, generate as much as you need.

What It Generates

NPC Dialogue — Multi-line dialogue with emotion tags, personality-consistent across calls
Item Descriptions — Lore-rich descriptions with rarity and genre tone
Quest Narratives — Full quest structure with objectives and reward context
World Lore — Faction histories, location descriptions, creation myths

All output is structured JSON — no parsing free-form text, just pull the fields you need.

Supported Genres

high_fantasy dark_fantasy sci_fi western horror cozy cyberpunk

Quick Start

Install

pip install requests

Get API Key

Sign up at RapidAPI
Search "GameForge Content"
Subscribe free (BASIC plan)
Copy your X-RapidAPI-Key

Generate NPC Dialogue

import requests

KEY = "YOUR_RAPIDAPI_KEY"
HOST = "gameforge-content.p.rapidapi.com"
BASE = f"https://{HOST}"
HEADERS = {"X-RapidAPI-Key": KEY, "X-RapidAPI-Host": HOST, "Content-Type": "application/json"}


def generate_npc_dialogue(name: str, role: str, personality: str, genre: str, location: str, situation: str):
    body = {
        "character": {
            "name": name,
            "role": role,
            "personality": personality
        },
        "genre": genre,
        "context": {
            "location": location,
            "situation": situation
        }
    }
    r = requests.post(f"{BASE}/npc/dialogue", json=body, headers=HEADERS)
    r.raise_for_status()
    return r.json()


# Example: generate dialogue for a blacksmith
dialogue = generate_npc_dialogue(
    name="Greta Ironhand",
    role="blacksmith",
    personality="gruff, proud of her craft, distrustful of mages",
    genre="high_fantasy",
    location="forge",
    situation="player asks about a legendary sword"
)

for line in dialogue["lines"]:
    print(f'[{line["emotion"]}] {line["text"]}')

Output:

[suspicious] Another one asking about the Dawnbreaker. What's your interest in it?
[proud] That blade took me three months and a dragon's scale. Not something I sell to anyone who walks in.
[cautious] If you're serious, bring me proof you've cleared the Ashwood bandits. Then we'll talk.

Generate Item Descriptions

def generate_item(name: str, item_type: str, rarity: str, genre: str, lore_hook: str = ""):
    body = {
        "item": {
            "name": name,
            "type": item_type,
            "rarity": rarity
        },
        "genre": genre,
        "lore_hook": lore_hook
    }
    r = requests.post(f"{BASE}/item/description", json=body, headers=HEADERS)
    r.raise_for_status()
    return r.json()


sword = generate_item(
    name="Ashveil",
    item_type="sword",
    rarity="legendary",
    genre="dark_fantasy",
    lore_hook="forged from the bones of a fallen god"
)

print(sword["description"])
print(f"\nFlavor: {sword['flavor_text']}")

Generate Quests

def generate_quest(quest_type: str, genre: str, setting: str, protagonist_level: str = "novice"):
    body = {
        "quest_type": quest_type,
        "genre": genre,
        "setting": setting,
        "protagonist_level": protagonist_level
    }
    r = requests.post(f"{BASE}/quest/generate", json=body, headers=HEADERS)
    r.raise_for_status()
    return r.json()


quest = generate_quest(
    quest_type="rescue",
    genre="high_fantasy",
    setting="cursed forest",
    protagonist_level="veteran"
)

print(f"Title: {quest['title']}")
print(f"Hook: {quest['hook']}")
print("\nObjectives:")
for obj in quest["objectives"]:
    print(f"  - {obj}")
print(f"\nReward hint: {quest['reward_hint']}")

Bulk Content Pipeline

For game content pipelines, generate in bulk and cache:

import json
from pathlib import Path


def generate_npc_roster(npcs: list[dict], genre: str, output_file: str):
    results = []
    for npc in npcs:
        print(f"Generating {npc['name']}...")
        dialogue = generate_npc_dialogue(
            name=npc["name"],
            role=npc["role"],
            personality=npc.get("personality", "neutral"),
            genre=genre,
            location=npc.get("location", "village"),
            situation="player greeting"
        )
        results.append({"npc": npc, "dialogue": dialogue})

    Path(output_file).write_text(json.dumps(results, indent=2))
    print(f"Saved {len(results)} NPCs to {output_file}")


npc_list = [
    {"name": "Brother Aldus",  "role": "priest",    "location": "chapel"},
    {"name": "Mira the Swift", "role": "scout",     "location": "outpost"},
    {"name": "Old Brennan",    "role": "innkeeper", "location": "tavern"},
]

generate_npc_roster(npc_list, "high_fantasy", "npcs_generated.json")

Unity / Godot Integration

The JSON output maps directly to scriptable objects or resource files:

# Export as Godot .tres resource format
def to_godot_resource(npc_name: str, dialogue: dict) -> str:
    lines = dialogue["lines"]
    entries = "\n".join(
        f'DialogueLine("{l["text"]}", "{l["emotion"]}"),'
        for l in lines
    )
    return f"""[gd_resource type="DialogueResource"]
[resource]
npc_name = "{npc_name}"
lines = [{entries}]"""

Why Use an API Instead of Running a Local Model?

No GPU required — works on any machine, including CI/CD pipelines
Consistent output format — structured JSON every time, no prompt engineering
Genre enforcement — the API keeps tone/vocabulary consistent across calls
Free tier — 100 requests/month, enough for a full indie game's worth of content

The API is live on RapidAPI — search "GameForge Content" by Circle of Wizards. Free BASIC tier, PRO ($9.99/mo) unlocks higher call limits for production pipelines.

Build a VIX Options Trading Dashboard in Python (Free API)

Patrick DeVos — Sat, 06 Jun 2026 19:57:42 +0000

The VIX — the CBOE Volatility Index — is the single most actionable indicator for options traders. When VIX spikes, options premiums explode. When VIX collapses, premium sellers get paid. Most traders watch it manually. This guide shows you how to automate it.

We'll use the SignalSage API on RapidAPI to pull live VIX-based signals and build a Python trading dashboard that tells you exactly what to do based on current market conditions.

What the Dashboard Does

Reads the current VIX regime (low/elevated/high)
Recommends the right options strategy for the environment
Identifies high-probability trade setups
Tracks the volatility magnet (mean-reversion signal)
Outputs a ranked action list every morning

Prerequisites

Python 3.8+
RapidAPI account (free tier works)
Basic options knowledge (know what an iron condor is)

Step 1: Get the API Key

Sign up at RapidAPI
Search "SignalSage"
Subscribe to the free BASIC plan
Copy your X-RapidAPI-Key

Step 2: Install Dependencies

pip install requests rich schedule

Step 3: The Dashboard

import requests
import schedule
import time
from datetime import datetime
from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich import box

console = Console()

RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY_HERE"
BASE_URL = "https://signalsage.p.rapidapi.com"
HEADERS = {
    "X-RapidAPI-Key": RAPIDAPI_KEY,
    "X-RapidAPI-Host": "signalsage.p.rapidapi.com"
}


def get_playbook():
    r = requests.get(f"{BASE_URL}/api/playbook", headers=HEADERS)
    r.raise_for_status()
    return r.json()


def get_setups():
    r = requests.get(f"{BASE_URL}/api/setups", headers=HEADERS)
    r.raise_for_status()
    return r.json()


def get_magnet():
    r = requests.get(f"{BASE_URL}/api/magnet", headers=HEADERS)
    r.raise_for_status()
    return r.json()


def vix_color(vix: float) -> str:
    if vix < 15:
        return "green"
    elif vix < 20:
        return "yellow"
    elif vix < 30:
        return "orange3"
    return "red"


def render_dashboard():
    console.clear()
    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    console.print(f"\n[bold cyan]SignalSage Options Dashboard[/bold cyan]  [dim]{now}[/dim]\n")

    # --- PLAYBOOK ---
    pb = get_playbook()
    data = pb.get("data", {})
    overview = data.get("marketOverview", {})
    vix = overview.get("vix", 0)
    vix_analysis = overview.get("vixAnalysis", "")
    key_levels = overview.get("keyLevels", "")
    top_setups = data.get("topSetups", [])

    color = vix_color(vix)
    console.print(Panel(
        f"[{color}]VIX: {vix:.2f}[/{color}]   {vix_analysis}\n\n[dim]{key_levels}[/dim]",
        title="[bold]Market Overview[/bold]",
        border_style=color
    ))

    # --- SETUPS ---
    setups = get_setups()
    setup_list = setups.get("high_conviction_setups", [])

    if setup_list:
        table = Table(box=box.ROUNDED, show_header=True, header_style="bold magenta")
        table.add_column("Symbol", style="cyan", width=8)
        table.add_column("Strategy", width=20)
        table.add_column("Direction", width=12)
        table.add_column("Confidence", justify="right")
        table.add_column("Notes", width=35)

        for s in setup_list[:8]:
            conf = s.get("confidence", 0)
            conf_color = "green" if conf > 0.7 else "yellow" if conf > 0.5 else "white"
            table.add_row(
                s.get("symbol", ""),
                s.get("strategy", ""),
                s.get("direction", ""),
                f"[{conf_color}]{conf:.0%}[/{conf_color}]",
                s.get("notes", "")[:35]
            )

        console.print("\n[bold]High-Conviction Setups[/bold]")
        console.print(table)
    else:
        console.print(Panel(
            "[yellow]No high-conviction setups right now.\nVIX regime suggests waiting for better entries.[/yellow]",
            title="Setups",
            border_style="yellow"
        ))

    # --- MAGNET ---
    magnet = get_magnet()
    magnet_text = magnet.get("magnetAnalysis", "")
    # Show first 400 chars of the magnet analysis
    console.print(Panel(
        magnet_text[:400] + ("..." if len(magnet_text) > 400 else ""),
        title="[bold]Volatility Magnet[/bold]",
        border_style="blue"
    ))

    console.print("\n[dim]Refreshes every 5 minutes. Press Ctrl+C to exit.[/dim]")


def run():
    render_dashboard()
    schedule.every(5).minutes.do(render_dashboard)

    while True:
        schedule.run_pending()
        time.sleep(1)


if __name__ == "__main__":
    try:
        run()
    except KeyboardInterrupt:
        console.print("\n[dim]Dashboard stopped.[/dim]")

Sample Output

SignalSage Options Dashboard  2026-06-06 09:31:00

╭─────────────────────── Market Overview ───────────────────────╮
│ VIX: 21.51   21.51 → IV elevated, avoid new trades           │
│                                                                │
│ SPY key levels: 580 / 570 / 560                               │
╰────────────────────────────────────────────────────────────────╯

High-Conviction Setups
╭────────┬──────────────────────┬────────────┬────────────┬─────────────────────────────────────╮
│ Symbol │ Strategy             │ Direction  │ Confidence │ Notes                               │
├────────┼──────────────────────┼────────────┼────────────┼─────────────────────────────────────┤
│ SPY    │ Iron Condor          │ Neutral    │ 78%        │ VIX elevated, sell both wings       │
│ QQQ    │ Put Credit Spread    │ Bullish    │ 65%        │ Support held at 200MA               │
╰────────┴──────────────────────┴────────────┴────────────┴─────────────────────────────────────╯

VIX Regime Cheat Sheet

VIX Level	Regime	Best Strategy
< 15	Low volatility	Buy straddles, avoid premium selling
15–20	Normal	Iron condors, defined-risk spreads
20–30	Elevated	Short strangles with wide strikes
> 30	Fear spike	Sell puts on pullbacks, cash-secured

The general rule: sell premium when VIX is high, buy it when VIX is low. SignalSage automates this regime detection so you don't have to track it manually every morning.

Automate the Morning Brief

import smtplib
from email.mime.text import MIMEText

def email_brief(to_addr: str):
    pb = get_playbook()
    vix = pb["data"]["marketOverview"]["vix"]
    analysis = pb["data"]["marketOverview"]["vixAnalysis"]

    body = f"VIX: {vix}\n{analysis}\n\nRun your dashboard for full setups."

    msg = MIMEText(body)
    msg["Subject"] = f"Morning Options Brief — VIX {vix}"
    msg["From"] = "your@gmail.com"
    msg["To"] = to_addr

    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as s:
        s.login("your@gmail.com", "app-password")
        s.send_message(msg)

Run it at 9 AM with cron: 0 9 * * 1-5 python brief.py

The API is live on RapidAPI — search "SignalSage" by Circle of Wizards. Free tier, no credit card required. PRO unlocks higher rate limits for algorithmic traders running this on a schedule.

How to Build an EVE Online Market Trading Bot in Python

Patrick DeVos — Sat, 06 Jun 2026 19:15:17 +0000

EVE Online has one of the most complex player-driven economies in gaming. Billions of ISK change hands every day through player-controlled markets across hundreds of star systems. If you've ever wanted to write a trading bot that finds profitable routes — this guide walks you through it using real, live market data.

We'll use the EVE Online Market Tool API on RapidAPI, which wraps the EVE ESI (EVE Swagger Interface) and does the heavy lifting of scanning thousands of market orders so you don't have to.

What We're Building

A Python script that:

Fetches current trading opportunities from the EVE market
Finds arbitrage routes between stations
Scores each opportunity by profit potential and volume
Prints a ranked list of trades to execute

Prerequisites

Python 3.8+
A free RapidAPI account (the API has a free tier)
Basic Python knowledge

Step 1: Get Your API Key

Go to RapidAPI and create a free account
Search for "EVE Online Market Tool"
Subscribe to the free BASIC plan
Copy your X-RapidAPI-Key from the API console

Step 2: Install Dependencies

pip install requests tabulate colorama

Step 3: The Trading Bot

import requests
import json
from tabulate import tabulate
from colorama import Fore, Style, init

init(autoreset=True)

RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY_HERE"
RAPIDAPI_HOST = "eve-online-market-tool.p.rapidapi.com"

BASE_URL = f"https://{RAPIDAPI_HOST}"

HEADERS = {
    "X-RapidAPI-Key": RAPIDAPI_KEY,
    "X-RapidAPI-Host": RAPIDAPI_HOST
}


def get_trading_opportunities():
    """Fetch station trading opportunities (buy low, sell high same station)."""
    response = requests.get(f"{BASE_URL}/scan/trading", headers=HEADERS)
    response.raise_for_status()
    return response.json()


def get_arbitrage_routes():
    """Fetch cross-region arbitrage routes (buy in one region, sell in another)."""
    response = requests.get(f"{BASE_URL}/scan/arbitrage", headers=HEADERS)
    response.raise_for_status()
    return response.json()


def get_npc_arbitrage():
    """Fetch NPC seeded items with player market arbitrage potential."""
    response = requests.get(f"{BASE_URL}/scan/npc-arbitrage", headers=HEADERS)
    response.raise_for_status()
    return response.json()


def analyze_item(item_name):
    """Get deep analysis for a specific item."""
    response = requests.get(
        f"{BASE_URL}/analyze/{item_name}",
        headers=HEADERS
    )
    response.raise_for_status()
    return response.json()


def format_isk(value):
    """Format ISK values with M/B suffixes."""
    if value >= 1_000_000_000:
        return f"{value/1_000_000_000:.1f}B"
    elif value >= 1_000_000:
        return f"{value/1_000_000:.1f}M"
    elif value >= 1_000:
        return f"{value/1_000:.1f}K"
    return f"{value:.0f}"


def display_trading_opportunities(data, top_n=10):
    """Display top station trading opportunities."""
    print(f"\n{Fore.CYAN}=== STATION TRADING OPPORTUNITIES ==={Style.RESET_ALL}")
    print("Buy and sell at the same station for guaranteed margin\n")

    if not data or "opportunities" not in data:
        print("No data available")
        return

    opportunities = sorted(
        data["opportunities"],
        key=lambda x: x.get("profit_margin_pct", 0),
        reverse=True
    )[:top_n]

    rows = []
    for opp in opportunities:
        margin = opp.get("profit_margin_pct", 0)
        color = Fore.GREEN if margin > 20 else Fore.YELLOW if margin > 10 else Fore.WHITE

        rows.append([
            color + opp.get("item_name", "Unknown") + Style.RESET_ALL,
            format_isk(opp.get("buy_price", 0)),
            format_isk(opp.get("sell_price", 0)),
            f"{margin:.1f}%",
            format_isk(opp.get("profit_per_unit", 0)),
            opp.get("volume_available", 0),
            opp.get("station_name", "Unknown")[:30]
        ])

    headers = ["Item", "Buy", "Sell", "Margin", "Profit/Unit", "Volume", "Station"]
    print(tabulate(rows, headers=headers, tablefmt="rounded_outline"))


def display_arbitrage_routes(data, top_n=10):
    """Display top arbitrage routes."""
    print(f"\n{Fore.CYAN}=== ARBITRAGE ROUTES ==={Style.RESET_ALL}")
    print("Buy in one region, haul to another for profit\n")

    if not data or "routes" not in data:
        print("No data available")
        return

    routes = sorted(
        data["routes"],
        key=lambda x: x.get("profit_total", 0),
        reverse=True
    )[:top_n]

    rows = []
    for route in routes:
        profit = route.get("profit_total", 0)
        color = Fore.GREEN if profit > 50_000_000 else Fore.YELLOW if profit > 10_000_000 else Fore.WHITE

        rows.append([
            color + route.get("item_name", "Unknown") + Style.RESET_ALL,
            route.get("buy_region", "?")[:20],
            route.get("sell_region", "?")[:20],
            format_isk(route.get("buy_price", 0)),
            format_isk(route.get("sell_price", 0)),
            format_isk(profit),
            route.get("quantity", 0)
        ])

    headers = ["Item", "Buy Region", "Sell Region", "Buy Price", "Sell Price", "Total Profit", "Qty"]
    print(tabulate(rows, headers=headers, tablefmt="rounded_outline"))


def main():
    print(f"{Fore.MAGENTA}╔══════════════════════════════════╗")
    print(f"║   EVE ONLINE MARKET TRADING BOT  ║")
    print(f"╚══════════════════════════════════╝{Style.RESET_ALL}")
    print("\nScanning markets...\n")

    try:
        # Fetch all data
        trading_data = get_trading_opportunities()
        arbitrage_data = get_arbitrage_routes()

        # Display results
        display_trading_opportunities(trading_data)
        display_arbitrage_routes(arbitrage_data)

        # Quick item analysis example
        print(f"\n{Fore.CYAN}=== ITEM DEEP DIVE: Tritanium ==={Style.RESET_ALL}")
        trit_data = analyze_item("Tritanium")
        if trit_data:
            print(json.dumps(trit_data, indent=2))

    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print(f"{Fore.RED}Invalid API key. Check your RapidAPI key.{Style.RESET_ALL}")
        elif e.response.status_code == 429:
            print(f"{Fore.RED}Rate limit hit. Upgrade to PRO for higher limits.{Style.RESET_ALL}")
        else:
            print(f"{Fore.RED}API Error: {e}{Style.RESET_ALL}")


if __name__ == "__main__":
    main()

Sample Output

╔══════════════════════════════════╗
║   EVE ONLINE MARKET TRADING BOT  ║
╚══════════════════════════════════╝

Scanning markets...

=== STATION TRADING OPPORTUNITIES ===
Buy and sell at the same station for guaranteed margin

╭─────────────────────┬──────────┬──────────┬────────┬────────────┬─────────┬────────────────────────────────╮
│ Item                │ Buy      │ Sell     │ Margin │ Profit/Unit│ Volume  │ Station                        │
├─────────────────────┼──────────┼──────────┼────────┼────────────┼─────────┼────────────────────────────────┤
│ PLEX                │ 4.1M     │ 5.3M     │ 29.3%  │ 1.2M       │ 847     │ Jita IV - Moon 4 - Caldari N..│
│ Skill Injector      │ 812M     │ 960M     │ 18.2%  │ 148M       │ 12      │ Jita IV - Moon 4 - Caldari N..│
│ Brutix Navy Issue   │ 218M     │ 255M     │ 17.0%  │ 37M        │ 3       │ Amarr VIII - Oris - Emperor F.│
╰─────────────────────┴──────────┴──────────┴────────┴────────────┴─────────┴────────────────────────────────╯

Strategy Notes

Station Trading (Best for Beginners)

Works in Jita (the main trade hub) and Amarr
Set buy orders slightly above lowest buyer, sell orders slightly below lowest seller
Target items with 15%+ margins and high daily volume
Ideal starting capital: 500M ISK+

Arbitrage (Intermediate)

Buy underpriced items in low-traffic regions, haul to Jita
Risk: price can move during haul time (minimize with fast ships)
Caldari Shuttle for scanning, Iteron for hauling
Use the /scan/npc-arbitrage endpoint for NPC station seeded items — these replenish automatically

Risk Management

Never invest more than 20% of capital in a single trade
Check the /analyze/{item} endpoint for price history trends before big positions
Avoid items with fewer than 5 sellers (illiquid, spread can disappear)

Going Further

The API also supports:

# Get NPC arbitrage (guaranteed replenish sources)
npc_data = get_npc_arbitrage()

# Analyze specific items for trend data  
analysis = analyze_item("Caldari Navy Raven")

PRO tier unlocks higher rate limits (1000 req/month vs 100 on free) — useful if you're running this on a schedule via cron.

Automating the Bot

Run it every hour with cron (Linux/Mac):

# crontab -e
0 * * * * /usr/bin/python3 /path/to/eve_bot.py >> /var/log/eve_bot.log 2>&1

Or Windows Task Scheduler for a daily market report to your inbox.

The full API is available on RapidAPI — search "EVE Online Market Tool" by Circle of Wizards. Free tier includes 100 requests/month, plenty for personal use or small bots.

Happy trading, Capsuleer. o7

Build an EVE Online Market Trading Bot in Python Using the ESI API

Patrick DeVos — Sat, 06 Jun 2026 19:12:47 +0000

We'll use the EVE Online Market Tool API on RapidAPI, which wraps the EVE ESI (EVE Swagger Interface) and does the heavy lifting of scanning thousands of market orders so you don't have to.

What We're Building

A Python script that:

Fetches current trading opportunities from the EVE market
Finds arbitrage routes between stations
Scores each opportunity by profit potential and volume
Prints a ranked list of trades to execute

Prerequisites

Python 3.8+
A free RapidAPI account (the API has a free tier)
Basic Python knowledge

Step 1: Get Your API Key

Go to RapidAPI and create a free account
Search for "EVE Online Market Tool"
Subscribe to the free BASIC plan
Copy your X-RapidAPI-Key from the API console

Step 2: Install Dependencies

pip install requests tabulate colorama

Step 3: The Trading Bot

import requests
import json
from tabulate import tabulate
from colorama import Fore, Style, init

init(autoreset=True)

RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY_HERE"
RAPIDAPI_HOST = "eve-online-market-tool.p.rapidapi.com"

BASE_URL = f"https://{RAPIDAPI_HOST}"

HEADERS = {
    "X-RapidAPI-Key": RAPIDAPI_KEY,
    "X-RapidAPI-Host": RAPIDAPI_HOST
}


def get_trading_opportunities():
    """Fetch station trading opportunities (buy low, sell high same station)."""
    response = requests.get(f"{BASE_URL}/scan/trading", headers=HEADERS)
    response.raise_for_status()
    return response.json()


def get_arbitrage_routes():
    """Fetch cross-region arbitrage routes (buy in one region, sell in another)."""
    response = requests.get(f"{BASE_URL}/scan/arbitrage", headers=HEADERS)
    response.raise_for_status()
    return response.json()


def get_npc_arbitrage():
    """Fetch NPC seeded items with player market arbitrage potential."""
    response = requests.get(f"{BASE_URL}/scan/npc-arbitrage", headers=HEADERS)
    response.raise_for_status()
    return response.json()


def analyze_item(item_name):
    """Get deep analysis for a specific item."""
    response = requests.get(
        f"{BASE_URL}/analyze/{item_name}",
        headers=HEADERS
    )
    response.raise_for_status()
    return response.json()


def format_isk(value):
    """Format ISK values with M/B suffixes."""
    if value >= 1_000_000_000:
        return f"{value/1_000_000_000:.1f}B"
    elif value >= 1_000_000:
        return f"{value/1_000_000:.1f}M"
    elif value >= 1_000:
        return f"{value/1_000:.1f}K"
    return f"{value:.0f}"


def display_trading_opportunities(data, top_n=10):
    """Display top station trading opportunities."""
    print(f"\n{Fore.CYAN}=== STATION TRADING OPPORTUNITIES ==={Style.RESET_ALL}")
    print("Buy and sell at the same station for guaranteed margin\n")

    if not data or "opportunities" not in data:
        print("No data available")
        return

    opportunities = sorted(
        data["opportunities"],
        key=lambda x: x.get("profit_margin_pct", 0),
        reverse=True
    )[:top_n]

    rows = []
    for opp in opportunities:
        margin = opp.get("profit_margin_pct", 0)
        color = Fore.GREEN if margin > 20 else Fore.YELLOW if margin > 10 else Fore.WHITE

        rows.append([
            color + opp.get("item_name", "Unknown") + Style.RESET_ALL,
            format_isk(opp.get("buy_price", 0)),
            format_isk(opp.get("sell_price", 0)),
            f"{margin:.1f}%",
            format_isk(opp.get("profit_per_unit", 0)),
            opp.get("volume_available", 0),
            opp.get("station_name", "Unknown")[:30]
        ])

    headers = ["Item", "Buy", "Sell", "Margin", "Profit/Unit", "Volume", "Station"]
    print(tabulate(rows, headers=headers, tablefmt="rounded_outline"))


def display_arbitrage_routes(data, top_n=10):
    """Display top arbitrage routes."""
    print(f"\n{Fore.CYAN}=== ARBITRAGE ROUTES ==={Style.RESET_ALL}")
    print("Buy in one region, haul to another for profit\n")

    if not data or "routes" not in data:
        print("No data available")
        return

    routes = sorted(
        data["routes"],
        key=lambda x: x.get("profit_total", 0),
        reverse=True
    )[:top_n]

    rows = []
    for route in routes:
        profit = route.get("profit_total", 0)
        color = Fore.GREEN if profit > 50_000_000 else Fore.YELLOW if profit > 10_000_000 else Fore.WHITE

        rows.append([
            color + route.get("item_name", "Unknown") + Style.RESET_ALL,
            route.get("buy_region", "?")[:20],
            route.get("sell_region", "?")[:20],
            format_isk(route.get("buy_price", 0)),
            format_isk(route.get("sell_price", 0)),
            format_isk(profit),
            route.get("quantity", 0)
        ])

    headers = ["Item", "Buy Region", "Sell Region", "Buy Price", "Sell Price", "Total Profit", "Qty"]
    print(tabulate(rows, headers=headers, tablefmt="rounded_outline"))


def main():
    print(f"{Fore.MAGENTA}╔══════════════════════════════════╗")
    print(f"║   EVE ONLINE MARKET TRADING BOT  ║")
    print(f"╚══════════════════════════════════╝{Style.RESET_ALL}")
    print("\nScanning markets...\n")

    try:
        # Fetch all data
        trading_data = get_trading_opportunities()
        arbitrage_data = get_arbitrage_routes()

        # Display results
        display_trading_opportunities(trading_data)
        display_arbitrage_routes(arbitrage_data)

        # Quick item analysis example
        print(f"\n{Fore.CYAN}=== ITEM DEEP DIVE: Tritanium ==={Style.RESET_ALL}")
        trit_data = analyze_item("Tritanium")
        if trit_data:
            print(json.dumps(trit_data, indent=2))

    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print(f"{Fore.RED}Invalid API key. Check your RapidAPI key.{Style.RESET_ALL}")
        elif e.response.status_code == 429:
            print(f"{Fore.RED}Rate limit hit. Upgrade to PRO for higher limits.{Style.RESET_ALL}")
        else:
            print(f"{Fore.RED}API Error: {e}{Style.RESET_ALL}")


if __name__ == "__main__":
    main()

Sample Output

╔══════════════════════════════════╗
║   EVE ONLINE MARKET TRADING BOT  ║
╚══════════════════════════════════╝

Scanning markets...

=== STATION TRADING OPPORTUNITIES ===
Buy and sell at the same station for guaranteed margin

╭─────────────────────┬──────────┬──────────┬────────┬────────────┬─────────┬────────────────────────────────╮
│ Item                │ Buy      │ Sell     │ Margin │ Profit/Unit│ Volume  │ Station                        │
├─────────────────────┼──────────┼──────────┼────────┼────────────┼─────────┼────────────────────────────────┤
│ PLEX                │ 4.1M     │ 5.3M     │ 29.3%  │ 1.2M       │ 847     │ Jita IV - Moon 4 - Caldari N..│
│ Skill Injector      │ 812M     │ 960M     │ 18.2%  │ 148M       │ 12      │ Jita IV - Moon 4 - Caldari N..│
│ Brutix Navy Issue   │ 218M     │ 255M     │ 17.0%  │ 37M        │ 3       │ Amarr VIII - Oris - Emperor F.│
╰─────────────────────┴──────────┴──────────┴────────┴────────────┴─────────┴────────────────────────────────╯

Strategy Notes

Station Trading (Best for Beginners)

Works in Jita (the main trade hub) and Amarr
Set buy orders slightly above lowest buyer, sell orders slightly below lowest seller
Target items with 15%+ margins and high daily volume
Ideal starting capital: 500M ISK+

Arbitrage (Intermediate)

Buy underpriced items in low-traffic regions, haul to Jita
Risk: price can move during haul time (minimize with fast ships)
Caldari Shuttle for scanning, Iteron for hauling
Use the /scan/npc-arbitrage endpoint for NPC station seeded items — these replenish automatically

Risk Management

Never invest more than 20% of capital in a single trade
Check the /analyze/{item} endpoint for price history trends before big positions
Avoid items with fewer than 5 sellers (illiquid, spread can disappear)

Going Further

The API also supports:

# Get NPC arbitrage (guaranteed replenish sources)
npc_data = get_npc_arbitrage()

# Analyze specific items for trend data  
analysis = analyze_item("Caldari Navy Raven")

PRO tier unlocks higher rate limits (1000 req/month vs 100 on free) — useful if you're running this on a schedule via cron.

Automating the Bot

Run it every hour with cron (Linux/Mac):

# crontab -e
0 * * * * /usr/bin/python3 /path/to/eve_bot.py >> /var/log/eve_bot.log 2>&1

Or Windows Task Scheduler for a daily market report to your inbox.

The full API is available on RapidAPI — search "EVE Online Market Tool" by Circle of Wizards. Free tier includes 100 requests/month, plenty for personal use or small bots.

Happy trading, Capsuleer. o7