Read the docs.

Install the package, set your API key, and make your first query in under a minute.

pip install xfinlink

Create a free account to get your API key, then:

import xfinlink as xfl

# Set your API key — get a free key at https://xfinlink.com/signup
xfl.set_api_key("YOUR_API_KEY")

# Historical prices
prices = xfl.prices("AAPL", start="2024-01-01")

# Financial statements
fundamentals = xfl.fundamentals("AAPL", period_type="annual")

# Pre-computed metrics (P/E, ROE, margins, ...)
metrics = xfl.metrics("AAPL", fields=["pe_ratio", "roe"])

# Index constituents
sp500 = xfl.index("sp500")

# Search for entities
results = xfl.search(q="apple")

# Entity resolution (handles ticker recycling)
entity = xfl.resolve("GM")

Use an API key via the X-API-Key header for full access (the Python client handles this automatically).

Most API requests require an API key. Create a free account to get yours. Search and resolve allow restricted unauthenticated calls; use a key for normal limits and full detail.

Pass the key via the X-API-Key header:

curl -H "X-API-Key: your-api-key" \
  https://api.xfinlink.com/v1/prices/AAPL?start=2024-01-01

The Python client handles auth automatically:

import xfinlink as xfl

# Set your API key — get a free key at https://xfinlink.com/signup
xfl.set_api_key("YOUR_API_KEY")

Your API key is shown on the dashboard after sign-up. You can regenerate it at any time.

OHLCV prices with split adjustment, total returns, and dividend/split event data. Coverage back to 1996 for every US-listed stock and ETF. Supports daily through yearly aggregation intervals.

Request:

df = xfl.prices("AAPL", start="2024-01-01", fields=["close", "volume"])

Response:

  date        ticker   close      volume
  2024-01-02  AAPL     185.64  45,123,456
  2024-01-03  AAPL     184.25  42,889,012
  2024-01-04  AAPL     181.91  49,301,234
  ...

Reported financials — income statement, balance sheet, cash flow — back to 1950 for most listed US companies.

df = xfl.fundamentals("AAPL", period_type="annual",
                fields=["revenue", "net_income"])
# With revenue segments
df = xfl.fundamentals("AAPL", include_segments=True)

Full entity history for a ticker. Every company that ever used this ticker, with validity dates, classifications, and index membership.

info = xfl.resolve("GM")
for entity in info["data"]["GM"]["entities"]:
    print(entity["name"], entity["ticker_valid_from"], entity["ticker_valid_to"])

Discover entities by name, sector, type, or classification code.

df = xfl.search(gics_sector="Consumer Staples")
df = xfl.search(q="apple")

Current and historical index constituents. Available indices: sp500, ndx100, djia, russell2000.

df = xfl.index("sp500")
df = xfl.index("sp500", as_of="2020-01-01")

Insider transactions from SEC Form 3, 4, and 5 filings. One row per transaction. Shares and prices are split-adjusted. Coverage 1986 to present. Pro tier only; free-tier keys receive 402.

Fields returned: entity_id, ticker, entity_name, transaction_date, filing_date, form_type, insider_name, insider_role, insider_role_other, transaction_code, transaction_type, acquisition_or_disposition, shares, shares_held_after, transaction_price, transaction_value, ownership_type, is_amendment, document_id, sequence_in_filing, data_quality.

df = xfl.insiders("TSLA", transaction_type="open_market_sell", insider_role="CEO")

37 pre-computed financial metrics derived from prices and fundamentals. All ratios as decimals (0.46 = 46%). Market cap and enterprise value in millions USD. Per-share values in dollars.

Valuation: market_cap, market_cap_diluted, enterprise_value, pe_ratio, ps_ratio, pb_ratio, price_to_cash_flow, ev_ebitda, earnings_yield, dividend_yield

Profitability: gross_margin, operating_margin, net_margin, ebitda_margin, roe, roa, roic

Leverage: debt_to_equity, debt_to_assets, long_term_debt_to_equity, long_term_debt_to_assets, current_ratio, quick_ratio, interest_coverage

Efficiency: asset_turnover, inventory_turnover

Per-share ($/share): revenue_per_share, book_value_per_share, tangible_book_value_per_share, cash_per_share, debt_per_share, ocf_per_share, fcf_per_share, ebit_per_share, ebitda_per_share, capex_per_share, working_capital_per_share

df = xfl.metrics("AAPL", fields=["pe_ratio", "roe", "market_cap"])

230+ data fields across seven endpoints. See the Explorer on the home page for live values.

xfinlink follows the academic convention for price data. This matters for backtesting and returns analysis.

Adjustment direction: adj_close is split-only backward-adjusted to the current post-split share basis. To derive a forward-adjusted series from an anchor date, request raw close plus split_ratio, then compound split ratios forward.

import xfinlink as xfl

df = xfl.prices("AAPL", start="2020-08-27", end="2020-09-02", fields=["close", "split_ratio"], adjust="none")
df = df.sort_values("date")

factor = df["split_ratio"].fillna(1.0).cumprod()
df["forward_adj_close"] = df["close"] * factor

date        ticker  close      split_ratio  forward_adj_close
2020-08-27  AAPL    500.04001  NaN          500.04001
2020-08-28  AAPL    499.23001  NaN          499.23001
2020-08-31  AAPL    129.03999  4.0          516.15996
2020-09-01  AAPL    134.17999  NaN          536.71996
2020-09-02  AAPL    131.39999  NaN          525.59996

Why no dividend-adjusted prices? Dividend-adjusted prices retroactively change every time a company pays a dividend, making historical values unstable. xfinlink stores stable values (split-only adjusted) plus total returns, which is the academic standard for quantitative research.

How to compute dividend-adjusted prices client-side:

import xfinlink as xfl

df = xfl.prices("AAPL", start="2020-01-01", fields=["adj_close", "return_daily"])

# Build cumulative total return index
df["total_return_index"] = (1 + df["return_daily"]).cumprod()

# Derive dividend-adjusted price series
df["div_adj_close"] = df["adj_close"].iloc[-1] * df["total_return_index"] / df["total_return_index"].iloc[-1]

Price fields and fundamentals fields are on different split-adjustment bases.

adj_close is split-only adjusted (no dividend adjustment). All fundamentals per-share fields (eps_diluted, dividends_per_share) are as-reported with no split adjustment. Do not combine them for ratios (P/E, P/B, etc.) unless no split occurred between the reporting date and today.

Path 1 — Code Generation

For developers with Python + IDE

1. Get your API key (free)
2. Install: pip install xfinlink
3. Copy the context block below and paste it into Claude, ChatGPT, or Cursor as system context
4. Describe what you want — the LLM writes working xfinlink code

Loading llms.txt…

Path 2 — Direct Access via MCP

Zero code — ask questions, get answers

1. Get your API key (free)
2. Pick your AI platform and connect using the server URL below
3. Ask anything — “What’s AAPL’s P/E ratio?” or “Compare top 5 banks by ROE”

Server URL

https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY

Replace YOUR_API_KEY with your key from the dashboard.

Available tools: get_prices, get_fundamentals, get_metrics, resolve_ticker, search, get_index, get_insiders

Claude (Anthropic)

Option A — Web (claude.ai)

1. Go to claude.ai and sign in
2. Click your profile icon → Settings → Connectors
3. Click + then Add custom connector
4. Name: xfinlink, URL: https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY
5. Click Create
6. Start a new chat and ask: “What’s NVDA’s P/E ratio?”

Available on Free (1 connector), Pro, Max, Team, and Enterprise plans.

Option B — Claude Desktop

1. Open Claude Desktop → Settings → Developer → Edit Config
2. Add to claude_desktop_config.json:

{
  "mcpServers": {
    "xfinlink": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY"]
    }
  }
}

3. Restart Claude Desktop

ChatGPT (OpenAI)

Requires Plus, Pro, Team, Enterprise, or Edu plan.

1. Open chatgpt.com → Settings → Apps & Connectors
2. Scroll to Advanced Settings → toggle Developer Mode on
3. Go back to Connectors → click Create
4. Name: xfinlink, MCP server URL: https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY, Authentication: None
5. Click Create
6. Start a new chat → click + → More → Developer Mode → Add sources → enable xfinlink
7. Ask: “Compare AAPL and MSFT revenue growth over the past 3 years”

Grok (xAI)

Option A — Web (grok.com)

Requires a paid Grok account.

1. Go to grok.com → Menu → Connectors
2. Click Add custom connector
3. Name: xfinlink, URL: https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY
4. Enable the connector per conversation
5. Ask: “Screen the S&P 500 for stocks with P/E below 20”

Option B — xAI API (Developer)

from openai import OpenAI

client = OpenAI(
    api_key="your-xai-api-key",
    base_url="https://api.x.ai/v1",
)

response = client.responses.create(
    model="grok-4.20-reasoning",
    input=[{"role": "user", "content": "What's AAPL's quarterly revenue trend?"}],
    tools=[{
        "type": "mcp",
        "server_url": "https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY",
        "server_label": "xfinlink",
    }],
)

Perplexity

Requires Pro, Max, or Enterprise plan.

1. Go to perplexity.ai → Account Settings → Connectors
2. Click + Custom connector → select Remote
3. Name: xfinlink, MCP Server URL: https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY, Authentication: None, Transport: Streamable HTTP
4. Check acknowledgement box → click Add
5. Click the xfinlink card to enable it
6. In a new search, toggle xfinlink under Sources
7. Ask: “What’s NVDA’s gross margin trend over the past 2 years?”

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "xfinlink": {
      "url": "https://api.xfinlink.com/mcp?api_key=YOUR_API_KEY"
    }
  }
}