How to Use Claude Fable 5 with FXMacroData for FX Trading
Author: FXMacroData Team
Published: June 10, 2026
Anthropic released Claude Fable 5 on June 9, 2026 as its most capable widely available model for long-horizon reasoning and agentic work. For FX builders, it is a better fit than the restricted-access Mythos track because it is the practical model you can wire into a live research workflow today. This guide shows how to use Claude Fable 5 with FXMacroData for macro-driven FX analysis and trade preparation.
The goal is simple: let Claude reason over structured macro data without forcing it to invent values. That means Claude should read real releases, rate decisions, positioning, and spot context from FXMacroData, then return a bounded trading view for pairs such as USD/JPY or EUR/USD.
Prerequisites
- An Anthropic API key with access to Claude Fable 5.
- An FXMacroData API key from the API management page. USD-only usage can start free; broader multi-currency work usually needs a paid plan.
- Python 3.11+ with
requestsandanthropicinstalled. - A clear rule that Claude does research and ranking, while your execution layer keeps final risk control.
Step 1. Decide what Claude should do and what FXMacroData should do
Use FXMacroData for facts and Claude for interpretation. That division matters. FXMacroData should supply the structured data: releases from the release calendar, prints from announcement series, central-bank context from the Federal Reserve or other policy desks, positioning from COT, and current or recent spot context.
Claude Fable 5 should do the high-level work on top of that data:
- Rank which release matters most.
- Explain the macro regime in plain language.
- Choose the cleanest pair expression.
- Return the answer in a strict machine-readable schema.
This is the difference between a usable FX assistant and a chatty bot. Claude should not be your price feed, your event store, or your risk engine.
Step 2. Set your environment and install the SDKs
Put both API keys in the environment so they stay out of prompts and out of your git history.
export ANTHROPIC_API_KEY="YOUR_ANTHROPIC_API_KEY"
export FXMD_API_KEY="YOUR_FXMACRODATA_API_KEY"
python -m pip install anthropic requests
From here on, every FXMacroData request should use the query-parameter auth pattern required by the platform:
curl "https://fxmacrodata.com/api/v1/announcements/usd/inflation?api_key=YOUR_API_KEY"
Step 3. Build a direct REST workflow around Claude Fable 5
The most stable production pattern is still explicit code. Pull the market context yourself, compress it into a compact payload, and then ask Claude Fable 5 to return a constrained trade-prep object.
A good first workflow is event-driven: one release series, one positioning overlay, one pair. For example, combine recent Japan CPI, the latest Bank of Japan communication, and spot behavior in USD/JPY.
import json
import os
import requests
from anthropic import Anthropic
FXMD_API = "https://fxmacrodata.com/api/v1"
FXMD_KEY = os.environ["FXMD_API_KEY"]
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
def get_json(path, **params):
response = requests.get(
f"{FXMD_API}{path}",
params={"api_key": FXMD_KEY, **params},
timeout=20,
)
response.raise_for_status()
return response.json()
context = {
"jpy_inflation": get_json("/announcements/jpy/inflation"),
"jpy_policy_rate": get_json("/announcements/jpy/policy_rate"),
"jpy_cot": get_json("/cot/jpy"),
"usd_jpy_spot": get_json("/forex", base="USD", quote="JPY"),
}
system_prompt = """
You are an FX macro research assistant.
Use only the supplied JSON context.
Do not invent values.
Do not recommend leverage.
Return JSON only with this schema:
{
"pair": "string",
"bias": "long|short|flat",
"confidence": 0.0,
"lead_driver": "string",
"thesis": "string",
"invalidation": "string",
"next_release_to_watch": "string"
}
"""
user_prompt = f"""
Evaluate USD/JPY using the supplied FXMacroData context.
Focus on what changed in Japan inflation and policy expectations,
how positioning changes the asymmetry, and whether the current setup
supports a directional bias over the next one to five sessions.
Context JSON:
{json.dumps(context)[:120000]}
"""
message = client.messages.create(
model="claude-fable-5",
max_tokens=1200,
system=system_prompt,
messages=[{"role": "user", "content": user_prompt}],
)
print(message.content[0].text)
This structure does three useful things. First, it pins Claude to live market data rather than memory. Second, it narrows the output contract so your downstream logic can reject malformed responses. Third, it keeps the model focused on one pair and one regime question instead of encouraging generic commentary.
Step 4. Add a release-first scanner before you ask for a trade view
The strongest use of Claude in FX is usually not "tell me what to trade" in the abstract. It is "tell me which scheduled event matters most, why, and where the asymmetry sits." Use the scanner first, then ask Claude for ranking.
A compact pre-trade prompt can look like this:
Pull the next 24 hours of releases for USD, EUR, GBP, JPY, AUD, and CAD.
For each release, summarize:
- indicator
- consensus and prior
- nearest liquid pair
- latest COT bias for the currency
- whether the market is already crowded
Then rank the top three events by likely FX impact and return JSON only.
To support that prompt with deterministic inputs, gather data from these paths:
curl "https://fxmacrodata.com/api/v1/calendar/usd?api_key=YOUR_API_KEY"
curl "https://fxmacrodata.com/api/v1/calendar/eur?api_key=YOUR_API_KEY"
curl "https://fxmacrodata.com/api/v1/cot/eur?api_key=YOUR_API_KEY"
curl "https://fxmacrodata.com/api/v1/forex?base=EUR"e=USD&api_key=YOUR_API_KEY"
This keeps the workflow release-led instead of price-led. That matters around high-impact regimes such as Non-Farm Payrolls, central-bank meetings, or CPI days when the macro print is the real catalyst and spot is only the reaction surface.
Step 5. Connect FXMacroData directly to Anthropic through the MCP connector
If you do not want to write the data-fetching code yourself every time, Anthropic's MCP connector can let Claude call FXMacroData tools directly from the Messages API. This is the shortest path from a plain-English request to a grounded macro answer.
The production FXMacroData MCP endpoint is documented at the MCP server page. Anthropic's API-side MCP connector uses an mcp_servers array plus an MCP toolset definition.
from anthropic import Anthropic
import os
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
response = client.beta.messages.create(
model="claude-fable-5",
max_tokens=1500,
messages=[
{
"role": "user",
"content": (
"Use FXMacroData to compare the latest ECB and Fed policy-rate "
"paths, then tell me whether EUR/USD has a widening or narrowing "
"rate-differential backdrop right now."
),
}
],
mcp_servers=[
{
"type": "url",
"url": "https://fxmacrodata.com/mcp",
"name": "fxmacrodata",
"authorization_token": os.environ["FXMD_MCP_BEARER"],
}
],
tools=[
{
"type": "mcp_toolset",
"mcp_server_name": "fxmacrodata",
}
],
betas=["mcp-client-2025-11-20"],
)
print(response.content[0].text)
If you prefer API-key style access for simple testing, use the FXMacroData REST path from the previous steps. For sustained Anthropic-native tool calling, the MCP connector is cleaner because Claude can decide when to call the relevant tool instead of forcing you to pre-wire every endpoint manually.
A useful first Anthropic prompt over MCP is:
Use FXMacroData tools to find the next high-impact release for the euro area,
compare it with the latest ECB rate level and current EUR/USD spot,
and return a one-paragraph trade-prep note plus a JSON risk summary.
Step 6. Put hard guardrails around the trading output
Claude Fable 5 is stronger than earlier models at long-horizon reasoning, but that does not remove trading risk. Treat the model like an analyst on your desk, not like an execution daemon.
At minimum, validate these fields before any signal reaches a live workflow:
- Schema validity: reject anything that breaks your JSON contract.
- Data freshness: reject output if the underlying release or spot snapshot is stale.
- Pair allowlist: force the model to choose only from supported liquid pairs.
- Risk completeness: require an invalidation level and next event to watch.
- No execution language: the model can propose a bias, not place a trade.
This is especially important when the setup depends on a live shift in rate expectations around the ECB, the Fed, or other central banks. The model should help you frame the trade, not silently widen your risk.
Wrapping up
Claude Fable 5 fits FXMacroData well because the pairing separates responsibilities cleanly: FXMacroData supplies the structured macro facts, and Claude turns those facts into a compact regime view, pair ranking, or event-prep note. For most teams, the best sequence is direct REST first, MCP second. REST gives you reproducibility. MCP gives you speed.
From here, the natural next step is to extend the same pattern to more event types: UK inflation, Australian unemployment, or multi-pair ranking ahead of the London open. Keep the prompts narrow, keep the output structured, and keep FXMacroData as the source of truth.
