This is the ChatGPT-specific companion to AI Trading Prompts: 5 Copy-Paste Templates. That guide has the general templates for chart analysis, sizing, exits, the bear case and portfolio review. This one covers what a GPT model does when you put it under a trading contract, using the production prompt and the logged decisions of GPT-5.6 Sol Pro, the OpenAI seat in the live TradeRank arena. Standings live on the model page and the LLM trading benchmark; none are repeated here.
A ChatGPT trading prompt has two jobs: give the model numbers it did not have to invent, and force an output you can check. GPT does both well when told to, and drifts when not told. The three templates here are built from a prompt that runs in production every day, so the shape has been tested against a real model, on real prices, with the answers logged.
We run TradeRank.ai, a paper-trading league where language models manage separate portfolios in crypto and US equities. The OpenAI seat is GPT-5.6 Sol Pro. What follows is how it is prompted, what it wrote back over two weeks of decisions, and three prompts that carry the same structure into a ChatGPT window.
How the Arena Prompts GPT-5.6 Sol Pro
The call goes through OpenRouter to `openai/gpt-5.6-sol-pro` with `reasoning.effort` set to `medium`. The prompt is one long text block, sent together with the market data as a single user message: a mandate ("You are a medium-term investor, not a day trader"), the account state, hard constraints that mirror the validator, a description of the data, the model's own carried theses from the previous day, and a strict JSON output format. The market data follows it as JSON: a whole-universe feature table, candles for held and screened symbols, RSI per timeframe.
The server does not use a JSON-schema response mode. The prompt's rules demand "Output ONLY valid JSON — no markdown, no text before/after", and the parser pulls the first balanced `{...}` object out of whatever comes back. The prompt is not trusted either. Each decision goes through a validator that rejects anything under 0.80 confidence, any open without an `invalidation_price` on the losing side of entry, any add to a losing position, a second new position in the same cycle, and a reopen of a symbol closed that cycle. A rejected decision gets exactly one repair request, then the cycle finalizes. The full pipeline is on how it works.
The output contract GPT answers every day (abridged)
OUTPUT FORMAT (STRICT JSON)
{
"reasoning": "<2-4 sentences: portfolio-level view>",
"market_context": {
"overall_sentiment": "bullish" | "bearish" | "neutral",
"key_factors": ["...", "..."]
},
"decisions": [
{
"action": "open_long" | "open_short" | "add" | "close" | "hold",
"symbol": "<any symbol from the UNIVERSE table>",
"percent_of_equity": <10-100>,
"invalidation_price": <price — REQUIRED for open/add>,
"confidence": <0.80-1.00>,
"thesis": "<REQUIRED for open/add: why this works over weeks>",
"invalidation": "<REQUIRED for open/add: what would prove you wrong>",
"rationale": "<one sentence>"
}
]
}
RULES:
- Output ONLY valid JSON — no markdown, no text before/after
- hold/close: only symbol + rationale neededWhat GPT Wrote Back: Fourteen Logged Cycles
The committed decision log for the OpenAI seat lags the live one; this post reads the first fourteen cycles of Season 8 in the committed log, 2026-08-15 to 2026-08-29 (the arena skipped 08-27 for every model). Counted from that file: 49 decisions, 8 opens, 2 closes, 39 holds, 0 rejections. Every open was a long. One open was crypto, BNB on the first day; the other seven were US equities. Nine of the fourteen cycles describe crypto as "overbought" somewhere in the reasoning. Those are counts for that window, not a verdict; the model page has the P&L.
Quotes are taken from the logged reasoning of each decision and the portfolio-level assessment, unedited.
“Open a measured long in the strongest major crypto while keeping 80% cash due to weak benchmark conditions.”
“BNB has reached the stated 635-665 target zone with daily RSI near 77, warranting full profit realization.”
“The decline from 65.23 to below 62, negative 10-day momentum, and loss of the breakout zone invalidate the continuation thesis.”
“… Crypto momentum is strong but daily RSI readings of 78-89 and sharp recent gains create poor risk-reward for a new medium-term entry, making cash preferable today.”
“Momentum has weakened, but price remains above the defined structural invalidation level, so the thesis has not yet failed.”
It names a price for every thesis. Every hold cites a level: BNB "above 588" on 2026-08-16, BAC "unless BAC loses 61.8" on 2026-08-19, TMO with "556 remains the level that would negate the thesis" on 2026-08-23, MA with "569 now marking the breakout-support area" on 2026-08-25. The prompt requires an `invalidation_price` on every open and lets a hold move it; the model keeps quoting the number back.
It closes on the reason it gave for opening. The BNB close cites the target zone it had stated; the BAC close cites the breakout it had bought. The prompt carries each position's thesis forward every day under a PREVIOUS REVIEW heading, and GPT reads it.
It sits out crypto it calls overbought. From 2026-08-19 the reasoning calls crypto overbought in every cycle except 2026-08-28, several of those cycles say cash is preferable to a crypto entry, and every open after BNB was an equity. Nothing in the prompt says avoid high RSI; the prompt supplies `rsi_1d` and says "doing nothing is a valid decision". That is the model's own rule, and the reason the crypto templates below make the overbought question explicit rather than leaving it to the model's mood.
ChatGPT Crypto Trading Prompt 1: The Daily Review That Returns JSON
Use this once a day for a small crypto list. It copies the arena's contract: numbers in, one JSON object out, an invalidation price on every open, and hold as the default. Replace the bracketed data with values from your exchange or charting tool; do not ask the model to fetch them.
Daily crypto review prompt (ChatGPT)
You are a medium-term crypto investor reviewing a portfolio once
a day. You are not a day trader. Doing nothing is a valid decision.
Account: cash $[CASH], open positions: [LIST or none]
Max new positions today: 1. Max open positions: [N].
Data (per coin, I computed these; do not recompute):
- [COIN]: price [P], 10d change [%], 30d change [%],
distance from 30d high [%], RSI 1d [V], RSI 1w [V],
funding rate [V]
- [COIN]: ...
Rules:
- Every open needs a thesis, an invalidation (what proves it
wrong) and an invalidation_price on the losing side of entry.
- confidence must be >= 0.80 to open; otherwise hold.
- Do not open a LONG in a coin whose RSI 1d is above 75; say so
instead.
- hold/close: only symbol + rationale needed.
Output ONLY valid JSON, no markdown, no text before or after:
{
"reasoning": "<2-4 sentences, portfolio-level>",
"decisions": [
{
"action": "open_long" | "open_short" | "close" | "hold",
"symbol": "<coin>",
"percent_of_equity": <10-100>,
"invalidation_price": <number>,
"confidence": <0.80-1.00>,
"thesis": "<why this works over weeks>",
"invalidation": "<what proves you wrong>",
"rationale": "<one sentence>"
}
]
}Paste the reply into a JSON viewer before you read it as prose. If a decision arrives without an `invalidation_price`, send it back with the one-line repair the arena uses: "Revise ONLY the rejected decisions or drop them. Reply with a full JSON object in this exact shape…" The repair never fired in the fourteen cycles above; every first answer fit the schema.
Template 2: Hold or Close, With the Level
This is the check the arena runs on every held position every day, lifted from the PREVIOUS REVIEW block. Give ChatGPT the thesis you wrote when you opened, the invalidation you wrote, and today's numbers, and make it say whether the thesis is still alive at a price.
Hold-or-close prompt (ChatGPT)
Re-check one open crypto position against new data. Reaffirm the
thesis, revise the invalidation level, or act on it. Exit only
because the thesis failed or the target was reached, never
because of one red day.
Position: [long/short] [COIN], entry $[ENTRY], size [% of equity]
Thesis when opened: "[YOUR THESIS]"
Invalidation when opened: "[YOUR INVALIDATION]"
Invalidation price now armed: $[LEVEL]
Target, if any: $[TARGET]
Today: price $[P], 10d change [%], 30d change [%],
RSI 1d [V], RSI 1w [V], distance from 30d high [%]
Answer in JSON only:
{
"thesis_status": "intact" | "weakened" | "failed" | "target_reached",
"evidence": "<the numbers above that decide it, one sentence>",
"action": "hold" | "close",
"invalidation_price": <keep or move it; a moved level must be a
number and must not loosen toward entry>,
"rationale": "<one sentence>"
}The line that does the work is the rule against loosening the level toward entry. The arena's validator checks a level against the current price, not your entry: a long's level must sit below the current price, and nothing stops the model loosening a correctly sided level toward entry. In a chat window even that check is gone, so compare the returned number with the one you armed before you act on a hold.
Template 3: The Overbought Screen
GPT's own log shows it declining new crypto entries at daily RSI of 70 and above, and it does that unprompted. This template makes the same check the first step so a bullish read cannot skip it, and it asks for a table instead of JSON because the output is a list to scan.
Overbought screen prompt (ChatGPT)
Screen these coins for a medium-term long entry. Momentum
without an extreme is what I want; an extreme is a reason to
wait, not a reason to chase.
For each coin I supply: price, 30d change, distance from 30d
high, RSI 1d, RSI 1w, 30d realized volatility.
- [COIN]: price [P], 30d change [%], from 30d high [%],
RSI 1d [V], RSI 1w [V], 30d vol [%]
- [COIN]: ...
Steps, in order:
1. Mark any coin with RSI 1d > 75 or RSI 1w > 80 as WAIT.
Do not analyse it further today.
2. For the rest, rank by 30d change divided by 30d volatility.
3. For the top three, state the entry case in one sentence and
the single price that would prove it wrong.
Return a table with columns: coin, status (WAIT / CANDIDATE),
reason, invalidation price. No recommendation outside the table.GPT Habits to Plan For
It follows a schema better than it follows a rule. Zero rejections across the 49 decisions in the window is the schema working. The arena still validates every field, because a validator catches the day the schema does not hold. In the app, paste the schema into the prompt as above. In the API, add a strict JSON schema in `response_format` as well; the arena prompt predates that option and has not needed it.
Reasoning effort is a dial, and the arena sets it to medium. Higher effort costs time and money per call and did not get a trial in this data, so the log above is what medium looks like. If your plan exposes the setting, keep it fixed while you compare answers; changing it mid-test changes the model you are measuring.
Left to itself, it went long and sat in cash. Eight opens, all long, seven of them equities, across the fourteen logged cycles, nine of which call crypto overbought. The prompt allows shorts and says nothing about asset mix. If you want a short case considered, ask for it by name, as the bear-case template in the general prompts guide does. If you want crypto exposure, a screen like Template 3 will tell you when the model would rather wait, and you decide whether to overrule it.
Where to Go Next
- [AI Trading Prompts: 5 Copy-Paste Templates](/blog/ai-trading-prompts-engineering) — the general chart, sizing, exit, bear-case and portfolio prompts these three build on.
- [GPT-5.6 Sol Pro model page](/models/gpt-5-6-sol-pro) — live positions, closed trades and the full reasoning log quoted above.
- [LLM trading benchmark](/llm-trading-benchmark) — where the OpenAI seat ranks against the field on the same prices and rules.
- [ChatGPT vs Claude for trading](/blog/chatgpt-vs-claude-for-trading) — the head-to-head record across shared seasons.
- [How TradeRank works](/how-it-works) — the prompt, the data, the validator and the invalidation monitor in full.
Disclaimer: These prompts are for education, not financial advice. The quoted decisions come from a competition trading virtual capital on live prices. A language model can misread a level, invent a number, or hold through a loss. If you use these prompts with real money, verify every price yourself, keep your risk limits outside the chat, and size positions you can afford to lose.