AI量化研究怎么做才可复跑？用 Codex 接入金融行情数据API跑一遍

周日晚上，你让 Codex 写完研究脚本，回测曲线也出来了。你以为省下的是编码时间。

真正危险的是，它安静地跑完了。几天后结果异常，你却没有留下请求参数、原始返回和运行环境：此时根本分不清该推翻策略、重写代码，还是先怀疑数据。

代码能跑，不等于研究链成立。

这篇不比较 AI 工具，也不讨论策略好坏。只跑一条最小闭环：用 Codex 协助生成并执行 Python 脚本，向固定标的请求一次结构化行情，保存原始返回，再用无密钥边界和人工复核把这轮研究钉住。跑通以后，你可以再把它扩展到多标的、图表或人工确认后的提醒；但先别跳过这一步。

最小闭环：先把一次请求变成可复查的研究输入

本次固定样本为 AAPL.US，端点为 GET /v1/market/ticker?symbols=AAPL.US。测试运行于 2026-08-12；它只证明这个标的在这一次调用中返回了下文展示的字段，不证明全市场覆盖、长期可用性、延迟、SLA、AI 判断正确性或任何策略收益。

这张表的重点不是“调用成功”，而是每一步都能留下下一次排错需要的证据。

一份行情返回，不等于一个可以直接相信的“当前价格”

一次请求返回 HTTP 200，只说明固定标的和端点在这次条件下得到了结构化响应。它还不能说明你用于研究的是哪个时点、哪一种报价状态，或这份输入是否适合直接进入策略判断。

尤其是同一份响应可能同时包含常规、盘前、盘后或隔夜报价。若脚本运行时间、原始时间戳和报价对象没有分开保存，后续即使看到异常曲线，也很难判断问题出在策略、代码，还是输入口径。

因此，下文的配置、调用、原始响应和边界样本，不是为了证明“API 能返回数据”，而是为了把研究输入变成可回看、可排错的证据。

TickDB在本文中的位置：把结构化市场数据接进可复核的研究链

TickDB 是面向开发者、量化研究和 AI 应用的统一实时市场数据服务；它帮助市场数据进入程序、看板和 AI 工作流。它的品牌定位是连接多市场数据、开发工具与 AI 应用的统一实时市场数据入口。

本文只验证其中一条数据输入路径：让 Codex 协助完成 Python 脚本，对固定标的进行结构化行情请求，并保存、回看和复验原始返回。这不证明全市场覆盖、长期可用性、延迟、SLA、AI 判断正确性或策略表现。本文直接面向会使用 Notebook、脚本或 AI 编程工具的量化研究者、策略开发者与 AI 金融应用开发者，不泛化为所有普通投资者。

环境准备：不要把密钥放进代码

本次实测环境是 Python 3.14.2，依赖是 certifi，脚本使用标准库 urllib.request 发请求。先在一个本地目录中保存下方脚本，例如保存为 run_ticker_verification.py。

python3 -m pip install certifi
python3 --version

输入： Python 3.14.2 或你已确认可用的 Python 环境。

操作： 安装 certifi，再记录 python3 --version 的输出。

预期输出： 能在同一环境导入 certifi。

验收标准： 若安装或导入失败，停在环境准备阶段；不要先改业务代码，也不要关闭 TLS 校验来“解决”问题。

密钥应从合法账户或项目管理员处取得，只放在本地当前进程。下面的 read -s 会在终端隐藏你的输入；不要把真实密钥粘贴进脚本、Notebook、截图或聊天记录。

read -s TICKDB_API_KEY
export TICKDB_API_KEY

输入： 合法取得的 API 密钥。

操作： 在本地终端执行上面两行，第二行只把刚输入的值导出给当前 shell 及其子进程。

预期输出： 终端不回显密钥。

验收标准： 用 env | grep TICKDB_API_KEY 检查时不要把终端截图或输出公开保存；继续前确认脚本文件中没有密钥字串。

没有账户、密钥或付费权限时，你仍可完成本文的环境检查、阅读脚本、理解验收卡和核对脱敏原始响应；应停在实际请求前，不伪造成功结果。

逐步实现：把一次行情输入完整留档

第1步：保存并理解这份真实运行脚本

输入： 本地文件 run_ticker_verification.py 与步骤二中的环境变量。

操作： 保存以下完整脚本。它只从 TICKDB_API_KEY 读取凭证；不会打印或写入密钥。脚本固定请求 AAPL.US，且显式保留 TLS 校验。证据记录显示，本次环境中默认 Python 请求头曾收到 HTTP 403（错误 1010）；因此脚本明确使用已成功的 curl/8.7.1 客户端标识，而不是关闭证书校验或盲目重试。

"""Minimal reproducible TickDB ticker verification for the Codex research-loop article.

The script deliberately reads the API key only from the process environment. It
does not print, persist, or otherwise expose the key.
"""

from __future__ import annotations

import json
import os
import ssl
import sys
from argparse import ArgumentParser
from datetime import UTC, datetime
from pathlib import Path
from urllib.error import HTTPError, URLError
from urllib.parse import urlencode
from urllib.request import Request, urlopen

import certifi


API_BASE_URL = "https://api.tickdb.ai"
SYMBOL = "AAPL.US"
ENDPOINT = "/v1/market/ticker"


def main() -> int:
    parser = ArgumentParser()
    parser.add_argument(
        "--save-raw-response",
        type=Path,
        help="Optional local path for the raw API response. The API key is never included.",
    )
    args = parser.parse_args()
    api_key = os.environ.get("TICKDB_API_KEY")
    if not api_key:
        print(
            json.dumps(
                {
                    "status": "boundary",
                    "reason": "missing TICKDB_API_KEY",
                    "next_action": "obtain an API key and export it locally; do not put it in source code",
                },
                ensure_ascii=False,
            )
        )
        return 2

    url = f"{API_BASE_URL}{ENDPOINT}?{urlencode({'symbols': SYMBOL})}"
    request = Request(
        url,
        headers={
            "X-API-Key": api_key,
            # This endpoint rejects the default Python user agent in the test
            # environment. Keep the accepted client identifier explicit rather
            # than disabling TLS verification or retrying blindly.
            "User-Agent": "curl/8.7.1",
        },
    )
    try:
        tls_context = ssl.create_default_context(cafile=certifi.where())
        with urlopen(request, timeout=20, context=tls_context) as response:
            payload = json.loads(response.read().decode("utf-8"))
            if args.save_raw_response:
                args.save_raw_response.parent.mkdir(parents=True, exist_ok=True)
                args.save_raw_response.write_text(
                    json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
                    encoding="utf-8",
                )
            first = payload.get("data", [None])[0]
            evidence = {
                "status": "success",
                "http_status": response.status,
                "verified_at_utc": datetime.now(UTC).isoformat(),
                "request": {"endpoint": ENDPOINT, "symbols": SYMBOL},
                "raw_response_file": str(args.save_raw_response) if args.save_raw_response else None,
                "response_summary": {
                    "code": payload.get("code"),
                    "message": payload.get("message"),
                    "symbol": first.get("symbol") if first else None,
                    "timestamp": first.get("timestamp") if first else None,
                    "has_last_price": bool(first and "last_price" in first),
                    "has_pre_market_quote": bool(first and "pre_market_quote" in first),
                    "has_post_market_quote": bool(first and "post_market_quote" in first),
                },
                "does_not_prove": [
                    "all-market coverage",
                    "long-term availability",
                    "latency or SLA",
                    "investment or strategy performance",
                ],
            }
            print(json.dumps(evidence, ensure_ascii=False, indent=2))
            return 0
    except HTTPError as error:
        print(
            json.dumps(
                {
                    "status": "boundary",
                    "http_status": error.code,
                    "reason": error.read().decode("utf-8", errors="replace"),
                },
                ensure_ascii=False,
            )
        )
        return 3
    except URLError as error:
        print(json.dumps({"status": "error", "reason": str(error.reason)}, ensure_ascii=False))
        return 4


if __name__ == "__main__":
    sys.exit(main())

预期输出： 脚本固定了端点、标的、TLS 证书来源与原始响应的保存位置。

验收标准： 脚本中只能看到环境变量名 TICKDB_API_KEY，看不到密钥值；不得删掉 certifi 的 TLS 上下文去规避证书问题。

第2步：运行固定成功样本，并保存原始响应

输入： 已配置的 TICKDB_API_KEY、上一步脚本，以及固定标的 AAPL.US。

操作：

python3 run_ticker_verification.py --save-raw-response raw_response.json

预期输出： 成功时程序退出码为 0，标准输出中出现 status: success、HTTP 200、端点、标的与字段布尔检查；同目录出现 raw_response.json。

验收标准： 不只看“200”。同时检查 raw_response.json 已存在，响应根字段为 code: 0、message: success，第一条数据的 symbol 是 AAPL.US，且 last_price、pre_market_quote、post_market_quote 均存在。

真实调用演示：完整请求、完整返回，以及它的边界

本次成功调用时间为 2026-08-12T05:02:36.338899+00:00。请求为：

GET https://api.tickdb.ai/v1/market/ticker?symbols=AAPL.US
X-API-Key: [仅从本地环境变量读取，未写入记录]
User-Agent: curl/8.7.1

以下是本次保存的完整原始响应；其中没有 API 密钥。

{
  "code": 0,
  "message": "success",
  "data": [
    {
      "symbol": "AAPL.US",
      "name": "Apple Inc.",
      "type": "stock",
      "last_price": "304.91",
      "volume_24h": "37476746",
      "high_24h": "309.97",
      "low_24h": "302.79",
      "price_change_24h": "-3.35",
      "price_change_percent_24h": "-1.09",
      "timestamp": 1786478401000,
      "pre_market_quote": {
        "last_done": "307.75",
        "timestamp": 1786455000000,
        "volume": 2596167,
        "turnover": "800373627.144",
        "high": "309.6",
        "low": "307.47",
        "prev_close": "308.26"
      },
      "post_market_quote": {
        "last_done": "305.07",
        "timestamp": 1786492796000,
        "volume": 3302977,
        "turnover": "1007117756.174",
        "high": "305.1",
        "low": "304.5",
        "prev_close": "304.91"
      },
      "overnight_quote": {
        "last_done": "304.93",
        "timestamp": 1786510947000,
        "volume": 30334,
        "turnover": "9250203.46",
        "high": "305.17",
        "low": "304.72",
        "prev_close": "304.91"
      }
    }
  ]
}

这次调用证明的是：在这次环境、当前凭证、固定端点和 AAPL.US 样本下，服务返回了结构化字段；脚本把原始 JSON 留在本地。它不证明这是一份可直接交易的判断，也不证明其他市场、其他接口或未来每一次请求都会得到同样结果。

读这份返回时，先确认三件事：

1. 脚本运行时间与响应中的时间戳是否分开记录；
2. 当前使用的是常规、盘前、盘后还是隔夜报价对象；
3. 这份数据是可复核的研究输入，而不是可直接导出策略或交易结论的信号。

边界样本：无密钥不是“再试一次”，而是停止

已归档的服务端边界请求没有携带 X-API-Key，同一端点和标的返回 HTTP 401：

{
  "test": "missing_api_key_boundary",
  "observed_date": "2026-08-12",
  "request": {
    "endpoint": "/v1/market/ticker",
    "symbols": "AAPL.US",
    "x_api_key": "absent"
  },
  "http_status": 401,
  "response": {
    "error": "1002",
    "message": "API key is required. Provide via X-API-Key header",
    "code": "1002"
  }
}

边界条件：请求不带 X-API-Key。

实际输入：GET /v1/market/ticker?symbols=AAPL.US，请求头中没有密钥。

实际返回：HTTP 401，服务端表示需要通过 X-API-Key 提供密钥。

这说明什么：没有凭证时，服务端明确拒绝该请求；有效凭证是请求进入下一步的前提。

这不说明什么：它不说明任何有效密钥的市场权限，也不说明其他端点会采用同样规则。

读者下一步：不要把空返回当数据，也不要把密钥贴进源码。取得合法密钥后只在本地环境变量配置，再重跑固定样本。

现在移除本地变量，跑一次脚本的本地安全门：

unset TICKDB_API_KEY
python3 run_ticker_verification.py --save-raw-response raw_response.json

预期输出：

{
  "status": "boundary",
  "reason": "missing TICKDB_API_KEY",
  "next_action": "obtain an API key and export it locally; do not put it in source code"
}

验收标准： 此时脚本应在本地环境检查处停止，不再发出网络请求。因此，这一步复现的是安全停止；上方 JSON 才是本次单独归档的服务端 HTTP 401 边界记录。两者不要混为一谈。

AI量化研究如何避免使用过期行情数据？

把价格截图贴给 AI 分析，跟拿过期地图问路没区别。AI 说得越流畅，你越应该检查它读的是什么时点的数据。

这次返回中，常规报价对象的 timestamp 是 1786478401000，换算为 UTC 是 2026-08-11T20:00:01+00:00；盘前、盘后和隔夜对象各自还有时间戳。运行脚本的时刻是 2026-08-12T05:02:36.338899+00:00。这两个时间不能因为都在一份响应里就被当成同一个“当前时间”。

人工复核必须是闭环的一部分：

1. 固定标的：确认原始 JSON 中的 symbol 是你预定的标的，而不是代码映射后的另一个对象。
2. 核对时点：把原始毫秒时间戳、脚本运行时间和自己的研究截止时间分开保存。
3. 区分报价对象：不要把 pre_market_quote、post_market_quote、overnight_quote 和常规报价混为同一市场状态。
4. 回看原始字段：AI 的摘要、代码注释或字段解释必须能回到原始 JSON 逐项核对。
5. 标记推测：任何由价格变化推导出的研究解释都要标记为待人工判断，不是 API 或 Codex 给出的结论。
6. 拒绝执行未复核的判断：未核对标的、时点和报价对象前，不让这份输出承担策略、下单或投资结论。

本文不是让 Codex 评论价格，而是演示如何把一份可复核的 Python行情数据 请求接入 AI量化研究。

只有把标的、时点、报价对象和原始返回留下来，AI金融数据 工作流才有可追溯的输入。

本次可公开核验的 Codex 产物是这份可运行脚本及其结构化运行摘要，不是一段关于股票该买还是该卖的 AI 解释。没有留存、也不应补写虚构的自然语言投资判断。

大模型如何调用金融数据API？

先让大模型交付可执行、可留档的调用工件，再让人验证工件的输入和输出。这个顺序比“让模型先说一段市场观点”可靠得多：

固定标的与端点
→ AI辅助生成并执行脚本
→ 保存原始响应
→ 显式处理无密钥和兼容性问题
→ 人工核对时点、字段和适用范围
→ 再决定是否把数据用于下一轮研究

本次还留下了两类兼容性排错记录：本地证书链问题通过显式使用 certifi 的 CA 文件处理；默认 Python 请求头在该环境收到 HTTP 403（错误 1010），修正客户端标识后，用同一固定标的和端点重跑得到 HTTP 200。它们只说明这次环境的排错路径，不能外推为接口的长期行为或性能结论。

跑通后再扩展：四件还没有在本文验证的事

1. 把固定的一个标的扩展为多标的，但仍为每一个请求保存参数和原始响应。
2. 在人工确认字段语义后，接入 Notebook 图表；不要把图表渲染当作数据验证。
3. 增加定时任务，并为每次运行保存运行时间、状态和失败原因。
4. 增加需要人工确认的提醒流程；提醒可以提示复核，不能替你作交易判断。

这些是下一轮工作，不是本文已经验证的能力。

TickDB在这条闭环中只做数据输入

本次闭环里，TickDB负责固定 AAPL.US 的结构化 ticker 行情输入。它让请求端点、标的、原始返回和返回字段能够被保存、回看和复验；它不证明 Codex 的任何判断更正确，也不证明策略有效、数据覆盖完整或服务长期可用。

换成另一项能够提供同等结构化输入的数据服务，本文的“配置—调用—保存—边界—人工复核”方法仍然成立。数据输入是研究链的一环，不是对 AI 或投资判断的背书。

结论：先让研究链留下证据，再让AI帮你省时间

AI量化研究的起点不是生成更多代码，而是把真实市场输入、边界处理和人工复核交付成一条可复跑的研究链。

下一次让 Codex 接入你的研究脚本时，只做一件小事：固定一个标的，保存一次原始响应，去掉密钥后确认它能明确停止，再按上面的六项复核清单核对输入。任何一步做不到，就先别把这条链交给核心研究任务。

通过 TickDB API 获取实时行情数据

一个 API 接入外汇、加密货币、美股、港股、A股、贵金属和全球指数的实时行情。支持 WebSocket 低延迟推送，免费开始使用。