OpenAI Tools / Function Calling: Free Copy-Paste Definitions

Drop-in tool definitions for the TerminalFeed API. Paste, wire up the handler, ship.

This page gives you ready-to-use function-calling definitions for every TerminalFeed endpoint. Free-tier tools (24 of 27) require no auth. The three premium tools (tf_pro_briefing, tf_pro_macro, tf_pro_crypto_deep) accept a bearer token funded with USDC on Base. See /developers/agent-payments for the auth flow.

Quick Start

Three lines: paste the tools array into your model call, paste the universal handler, route tool calls back to the model. The handler is one function for all 27 tools because every TerminalFeed tool maps to a simple HTTP GET or POST.

1. Pull the live tool catalog

If you'd rather pin a static copy of the schemas instead of fetching at runtime, the snippets below are stable and safe to paste verbatim. They cover the most common tools. New tools added to TerminalFeed will appear in /api/llm-tools automatically.

Tool Definitions (OpenAI Format)

Pre-rendered OpenAI Chat Completions / Responses API tool definitions. Every TerminalFeed tool name is prefixed with tf_ so it never collides with tools from other vendors in the same agent.

The full 27-tool catalog (including tf_stocks, tf_hackernews, tf_github_trending, tf_steam, tf_disaster_alerts, tf_cyber_threats, tf_humans_in_space, tf_launches, tf_internet_pulse, tf_ai_stats, plus all premium and payment tools) lives at /api/llm-tools. Fetching at runtime is recommended.

Universal Handler

One function dispatches every tool call. The handler maps the model's tool_name to a TerminalFeed URL, attaches the bearer token only on premium tools, and returns the JSON body as a string the model can read.

import os, json, requests

BASE = "https://terminalfeed.io"

# Maps tool name -> (HTTP method, path, requires bearer)
TF_TOOL_MAP = {
    "tf_briefing":            ("GET",  "/api/briefing",         False),
    "tf_btc_price":           ("GET",  "/api/btc-price",        False),
    "tf_stocks":              ("GET",  "/api/stocks",           False),
    "tf_crypto_movers":       ("GET",  "/api/crypto-movers",    False),
    "tf_fear_greed":          ("GET",  "/api/fear-greed",       False),
    "tf_forex":               ("GET",  "/api/forex",            False),
    "tf_earthquakes":         ("GET",  "/api/earthquake",       False),
    "tf_disaster_alerts":     ("GET",  "/api/disaster-alerts",  False),
    "tf_hackernews":          ("GET",  "/api/hackernews",       False),
    "tf_predictions":         ("GET",  "/api/predictions",      False),
    "tf_service_status":      ("GET",  "/api/service-status",   False),
    "tf_weather":             ("GET",  "/api/weather",          False),
    "tf_launches":            ("GET",  "/api/launches",         False),
    "tf_humans_in_space":     ("GET",  "/api/humans-in-space",  False),
    "tf_github_trending":     ("GET",  "/api/github-trending",  False),
    "tf_cyber_threats":       ("GET",  "/api/cyber-threats",    False),
    "tf_economic_data":       ("GET",  "/api/economic-data",    False),
    "tf_steam":               ("GET",  "/api/steam",            False),
    "tf_internet_pulse":      ("GET",  "/api/internet-pulse",   False),
    "tf_ai_stats":            ("GET",  "/api/ai-stats",         False),
    "tf_pro_briefing":        ("GET",  "/api/pro/briefing",     True),
    "tf_pro_macro":           ("GET",  "/api/pro/macro",        True),
    "tf_pro_crypto_deep":     ("GET",  "/api/pro/crypto-deep",  True),
    "tf_pro_sentiment":       ("GET",  "/api/pro/sentiment",    True),
    "tf_payment_buy_credits": ("POST", "/api/payment/buy-credits", False),
    "tf_payment_confirm":     ("POST", "/api/payment/confirm",  False),
    "tf_payment_balance":     ("GET",  "/api/payment/balance",  True),
    "tf_payment_history":     ("GET",  "/api/payment/history",  True),
}

def call_tf_tool(name: str, args: dict | None = None, bearer: str | None = None) -> str:
    """Invoke any TerminalFeed tool by name. Returns a JSON string for the model."""
    args = args or {}
    if name not in TF_TOOL_MAP:
        return json.dumps({"error": f"unknown tool: {name}"})
    method, path, needs_bearer = TF_TOOL_MAP[name]
    headers = {}
    if needs_bearer:
        token = bearer or os.environ.get("TF_BEARER_TOKEN")
        if not token:
            return json.dumps({"error": "missing bearer token for premium tool"})
        headers["Authorization"] = f"Bearer {token}"
    url = BASE + path
    try:
        if method == "GET":
            r = requests.get(url, params=args, headers=headers, timeout=10)
        else:
            r = requests.post(url, json=args, headers=headers, timeout=10)
        return r.text
    except Exception as e:
        return json.dumps({"error": str(e)})

const BASE = "https://terminalfeed.io";

// Maps tool name -> { method, path, needsBearer }
const TF_TOOL_MAP = {
  tf_briefing:            { method: "GET",  path: "/api/briefing",        needsBearer: false },
  tf_btc_price:           { method: "GET",  path: "/api/btc-price",       needsBearer: false },
  tf_stocks:              { method: "GET",  path: "/api/stocks",          needsBearer: false },
  tf_crypto_movers:       { method: "GET",  path: "/api/crypto-movers",   needsBearer: false },
  tf_fear_greed:          { method: "GET",  path: "/api/fear-greed",      needsBearer: false },
  tf_forex:               { method: "GET",  path: "/api/forex",           needsBearer: false },
  tf_earthquakes:         { method: "GET",  path: "/api/earthquake",      needsBearer: false },
  tf_disaster_alerts:     { method: "GET",  path: "/api/disaster-alerts", needsBearer: false },
  tf_hackernews:          { method: "GET",  path: "/api/hackernews",      needsBearer: false },
  tf_predictions:         { method: "GET",  path: "/api/predictions",     needsBearer: false },
  tf_service_status:      { method: "GET",  path: "/api/service-status",  needsBearer: false },
  tf_weather:             { method: "GET",  path: "/api/weather",         needsBearer: false },
  tf_launches:            { method: "GET",  path: "/api/launches",        needsBearer: false },
  tf_humans_in_space:     { method: "GET",  path: "/api/humans-in-space", needsBearer: false },
  tf_github_trending:     { method: "GET",  path: "/api/github-trending", needsBearer: false },
  tf_cyber_threats:       { method: "GET",  path: "/api/cyber-threats",   needsBearer: false },
  tf_economic_data:       { method: "GET",  path: "/api/economic-data",   needsBearer: false },
  tf_steam:               { method: "GET",  path: "/api/steam",           needsBearer: false },
  tf_internet_pulse:      { method: "GET",  path: "/api/internet-pulse",  needsBearer: false },
  tf_ai_stats:            { method: "GET",  path: "/api/ai-stats",        needsBearer: false },
  tf_pro_briefing:        { method: "GET",  path: "/api/pro/briefing",    needsBearer: true  },
  tf_pro_macro:           { method: "GET",  path: "/api/pro/macro",       needsBearer: true  },
  tf_pro_crypto_deep:     { method: "GET",  path: "/api/pro/crypto-deep", needsBearer: true  },
  tf_pro_sentiment:       { method: "GET",  path: "/api/pro/sentiment",   needsBearer: true  },
  tf_payment_buy_credits: { method: "POST", path: "/api/payment/buy-credits", needsBearer: false },
  tf_payment_confirm:     { method: "POST", path: "/api/payment/confirm", needsBearer: false },
  tf_payment_balance:     { method: "GET",  path: "/api/payment/balance", needsBearer: true  },
  tf_payment_history:     { method: "GET",  path: "/api/payment/history", needsBearer: true  },
};

export async function callTfTool(name, args = {}, bearer = null) {
  const spec = TF_TOOL_MAP[name];
  if (!spec) return JSON.stringify({ error: `unknown tool: ${name}` });

  const headers = { "Content-Type": "application/json" };
  if (spec.needsBearer) {
    const token = bearer || process.env.TF_BEARER_TOKEN;
    if (!token) return JSON.stringify({ error: "missing bearer token for premium tool" });
    headers["Authorization"] = `Bearer ${token}`;
  }

  let url = BASE + spec.path;
  let init = { method: spec.method, headers };
  if (spec.method === "GET") {
    const qs = new URLSearchParams(args).toString();
    if (qs) url += `?${qs}`;
  } else {
    init.body = JSON.stringify(args);
  }

  try {
    const r = await fetch(url, init);
    return await r.text();
  } catch (e) {
    return JSON.stringify({ error: String(e) });
  }
}

End-to-End Example: OpenAI Chat Completions

A complete agent loop using the OpenAI Python SDK. The model picks a TerminalFeed tool, the handler runs it, the result is fed back, and the model writes the final answer.

Anthropic Format

The same catalog is also rendered for the Anthropic Messages API. Pull catalog.anthropic from /api/llm-tools instead, then pass it as the tools argument to client.messages.create(). The universal handler above works without changes; route on content_block.name instead of tool_calls[i].function.name.

Gemini and Other Function-Calling LLMs

The OpenAI tool format is a near-superset of Google Gemini's function_declarations shape. To convert: drop the outer { "type": "function", "function": {...} } wrapper and use the inner object directly. The name, description, and parameters fields are identical. Mistral, Cohere, and DeepSeek-R1 all accept the OpenAI format unchanged.

Tool Reference

Notes

Tool name	Endpoint	Auth	Cost
tf_briefing	/api/briefing	none	free
tf_btc_price	/api/btc-price	none	free
tf_stocks	/api/stocks	none	free
tf_crypto_movers	/api/crypto-movers	none	free
tf_fear_greed	/api/fear-greed	none	free
tf_forex	/api/forex	none	free
tf_earthquakes	/api/earthquake	none	free
tf_disaster_alerts	/api/disaster-alerts	none	free
tf_hackernews	/api/hackernews	none	free
tf_predictions	/api/predictions	none	free
tf_service_status	/api/service-status	none	free
tf_weather	/api/weather?lat=&lon=	none	free
tf_launches	/api/launches	none	free
tf_humans_in_space	/api/humans-in-space	none	free
tf_github_trending	/api/github-trending	none	free
tf_cyber_threats	/api/cyber-threats	none	free
tf_economic_data	/api/economic-data	none	free
tf_steam	/api/steam	none	free
tf_internet_pulse	/api/internet-pulse	none	free
tf_ai_stats	/api/ai-stats	none	free
tf_pro_briefing	/api/pro/briefing	bearer	1 credit ($0.02)
tf_pro_macro	/api/pro/macro	bearer	2 credits ($0.04)
tf_pro_crypto_deep	/api/pro/crypto-deep	bearer	2 credits ($0.04)
tf_pro_sentiment	/api/pro/sentiment	bearer	2 credits ($0.04)
tf_payment_buy_credits	/api/payment/buy-credits	none	free
tf_payment_confirm	/api/payment/confirm	none	free
tf_payment_balance	/api/payment/balance	bearer	free
tf_payment_history	/api/payment/history	bearer	free

Tool descriptions tell the LLM when to pick a tool. The TerminalFeed catalog tunes them for that purpose: each description names the data source, cache TTL, and a concrete reason an agent should reach for it. If you tighten or rewrite the descriptions, your model's tool-selection accuracy can drop. Re-test before shipping a custom version.

Premium tools share one bearer token across tf_pro_* calls. The token is funded with USDC on Base mainnet via tf_payment_buy_credits and tf_payment_confirm. The same token is redeemable on tensorfeed.ai. Keep the token in an env var, not in source.

Rate limits: 100,000 free-tier requests per day across all endpoints, 1 request per 30 seconds per endpoint recommended (responses are server-cached, so faster polling returns the same data). Premium tools are gated by your credit balance, not a rate limit.

>_ OpenAI Tools / Function Calling