# Oxford Ledge (pypi · oxford-ledge-mcp)

Ask your assistant; it reads the public record: SEC filings, 13F, insider trades, BDC loans.

- Trust score: 61/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-30

## Components

- remote · `www.oxfordledge.com`: 35/100, [markdown](https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/www.md), [page](https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/www)
- pypi · `oxford-ledge-mcp`: 61/100 (this document), [markdown](https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/oxford-ledge-mcp.md), [page](https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/oxford-ledge-mcp)

## Channel facts

- Registry: `pypi`
- Package: `oxford-ledge-mcp`
- Version: `3.8.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-30.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to hs902/oxford-ledge-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 2 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 67/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 8275 tokens (~285/item across 29 items; 29 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 29 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 30 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 20/100
  - Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Oxford Ledge MCP server?

Oxford Ledge runs locally as a PyPI package, launched with uvx oxford-ledge-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-oxfordledge-oxford-ledge -- uvx oxford-ledge-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "com-oxfordledge-oxford-ledge": {
      "command": "uvx",
      "args": [
        "oxford-ledge-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-oxfordledge-oxford-ledge": {
      "command": "uvx",
      "args": [
        "oxford-ledge-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-oxfordledge-oxford-ledge -- uvx oxford-ledge-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-oxfordledge-oxford-ledge": {
      "type": "local",
      "command": [
        "uvx",
        "oxford-ledge-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-oxfordledge-oxford-ledge --command uvx --arg oxford-ledge-mcp
```

### Hermes

```yaml
mcp_servers:
  com-oxfordledge-oxford-ledge:
    command: "uvx"
    args: ["oxford-ledge-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-oxfordledge-oxford-ledge": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "oxford-ledge-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-oxfordledge-oxford-ledge -t stdio -c uvx -a oxford-ledge-mcp
```

### Other

```json
{
  "mcpServers": {
    "com-oxfordledge-oxford-ledge": {
      "command": "uvx",
      "args": [
        "oxford-ledge-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-30 (score 61, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-29 (score 76, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-28 (score 61, −5)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-27 (score 66)

First indexed and scored.

## MCP tools (29)

### `get_holders` (~220 tokens)

[Tier: free] Top 10 institutional shareholders of a stock from SEC 13F-HR filings: common-stock (COM) positions only, one row per filer at that filer's LATEST 13F within the last 6 quarters, ranked by reported dollar value. Returns {ticker, holders, completeness}; each row carries holder, fund_cik, shares, value (whole USD), type, quarter, filingDate. One call can mix quarters: read `asOf`, `vintages` and `coverage` before comparing rows. A stale filer whose shares reconcile to same-quarter siblings of its own fund family is WITHHELD into `superseded_parents`; do NOT add those rows back into `holders` or into any total, which restores the double count the fold removes. An empty `holders` list is a scoped statement, not proof that nobody owns the stock. `ticker` is required. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `ticker` (string, required): Stock ticker symbol

### `get_sec_filings` (~189 tokens)

[Tier: free] The 10 most recent EDGAR submissions for a company, of ANY form (Form 4 and Rule 144 notices dominate for large filers), unless `filing_type` narrows it to one exact form plus its /A amendments. Returns {ticker, filings, completeness}; each row is {form, title, date (filing date), url (the EDGAR document)}. The read covers only SEC's most-recent-1000 submissions index for the filer, so nothing older than `completeness.windowFrom` is visible here. Fetched directly from data.sec.gov (no key needed); cached 1h. Caveats ride the response's tool_notes.

Input parameters:

- `filing_type` (string): Filing type filter (10-K, 10-Q, 8-K, etc). Optional.
- `ticker` (string, required): Stock ticker symbol

### `get_insider_trades` (~260 tokens)

[Tier: free] Form 4 insider transactions for one issuer from Oxford Ledge's Form 4 ingest of SEC EDGAR: the latest `limit` rows by filing date (default 20, cap 100; `days` keeps rows filed in the last N days), every SEC transaction code. Returns {ticker, trades, completeness}; rows carry insider, position, signed shares, pricePerShare, value, type (raw SEC code), transTypeLabel, is_open_market (P and S only), isDerivative, transactionDate, filingDate, url. Rows with isDerivative true are option legs, awards or notes, not common-stock trades: do not add them to share counts. A 4/A that repeats its original line is served once (supersedesAccession names the folded original). Leave issuerSelfFiled rows out of any total. `ticker` is required. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `days` (integer): Only rows FILED in the last N days (optional; default: no window).
- `limit` (integer): Max rows, newest filing first (default 20, hard cap 100).
- `ticker` (string, required): Stock ticker symbol

### `get_fundamentals` (~261 tokens)

[Tier: free] XBRL-parsed annual financial statements for one ticker, fetched directly from SEC EDGAR companyfacts (10-K, 20-F and 40-F filers reporting under US GAAP in USD). Returns {ticker, data, concepts, coverage, coverageNote, basis}; `data` maps Revenue, NetIncome, EPS, DilutedShares, TotalAssets, TotalLiabilities, StockholdersEquity, OperatingCashFlow and LongTermDebt -- to up to 10 annual {period, value} points, newest first, in whole USD (EPS in USD per share). `LongTermDebt` is NOT total debt. An EPS or share series that spans a stock split is withheld on the pre-split side ({value: null, withheld: 'split_basis'}), never rescaled; `basis` is Oxford Ledge's split-basis check and every other value is the filing's, verbatim. An IFRS reporter, or a Canadian MJDS filer reporting on 6-K in CAD, is refused as DATA_UNAVAILABLE. No key needed; cached 1h. Caveats ride the response's tool_notes.

Input parameters:

- `ticker` (string, required): Stock ticker symbol (e.g. AAPL)

### `get_yield_curve` (~241 tokens)

[Tier: free] Current U.S. Treasury constant-maturity yield curve read directly from FRED's DGS series (1M, 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y, 20Y, 30Y). Returns {yield_curve: {tenor: percent}, as_of: {tenor: observation date}, source}; values are PERCENT numbers (4.18 means 4.18%), the newest non-suppressed observation per tenor. include_history=true adds `yield_curve_1y_ago` (the observation nearest one year before each tenor's as_of, within 45 days) and `history_coverage`. A partial curve carries a `completeness` block naming the missing tenors; a curve with no readable tenor raises DATA_UNAVAILABLE. Verbatim FRED values, nothing derived. Requires FRED_API_KEY; cached 1h. Caveats ride the response's tool_notes.

Input parameters:

- `include_history` (boolean): Include yield curve from 1 year ago for comparison (default false)

### `get_fred_data` (~298 tokens)

[Tier: free] One FRED series' observations, read directly from the FRED API. Returns {series, name, units, frequency, data, count}; `data` is [{date, value}] NEWEST FIRST over the trailing `days` calendar days (default 365, 1..36500). Units vary BY SERIES, so read `units` before comparing anything. U.S.-government / public-domain series only, decided in three steps: a REFUSED roster of 14 ids with a known non-government rights holder (the ICE BofA OAS family, VIXCLS, UMCSENT, MICH, SP500, DJIA, NASDAQCOM, MORTGAGE30US, AAA) is refused with INVALID_PARAMS and NO request at all; a CLEARED roster of 40 reviewed federal series always serves; anything else is decided by FRED's own series metadata -- a third-party copyright notice or a named licensor is refused. Requires FRED_API_KEY; cached 1h. Caveats ride the response's tool_notes.

Input parameters:

- `days` (integer): Number of calendar days of history back from today (default 365; 1..36500)
- `series` (string, required): FRED series ID (e.g. GDP, UNRATE, CPIAUCSL, DFF); must match ^[A-Z0-9_.-]{1,40}$

### `get_corporate_events` (~290 tokens)

[Tier: free] The 20 most recent 8-K item events for a ticker from Oxford Ledge's 8-K index of SEC EDGAR, NEWEST FIRST -- a fixed window with no caller-settable limit, so a recent-events feed, not a history. Returns {ticker, count, events, coverage, summary}; each event is {ticker, eventDate, eventType, headline, description, counterparty, counterpartyTicker, source, sourceUrl}. `eventType` is Oxford Ledge's 8-K item-to-category map (the one derived field); `description` is an excerpt of the filing text. `event_type` filters on the stored category; for M&A use acquisition_disposition. An unreachable store REFUSES rather than serving events=[]. `ticker` is required. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `event_type` (string): Optional filter (lowercase, case-sensitive). 8-K item categories (material_agreement, acquisition_disposition, executive_change, shareholder_vote, ...) are what the 8-K writers actually store; divide…
- `ticker` (string, required): Stock ticker symbol (e.g. AAPL)

### `search_bdc_borrower` (~343 tokens)

[Tier: free] Which BDCs lend to one private-credit borrower, matched fuzzily on name -- Oxford Ledge's parse of SEC EDGAR BDC schedules of investments (ol-derived), not filer-published data. Returns borrowerName, borrowerNorm (the key get_bdc_borrower_mark_history and the ol_bdc_* tools take), description, descriptionSource, industry, aggregates over CURRENT holders (totalHolders, totalParAmount, totalFairValue, avgMarkedPrice) and `holders`, one row per TRANCHE. ABOVE-PAR TRAP: a mark above 100 is a par-basis artifact until fairValue is checked against cost, NOT a credit premium. `description` is a company profile, NOT filing text; a profile whose writer is not established is served with `_meta.ai_generated: true`. A miss is {found: false} -- a search miss, not a finding of no BDC exposure. `limit` / `offset` page `holders` only. Source: SEC EDGAR BDC schedules of investments (~45-60 day lag). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Max `holders` rows to return (default 5000 = every row; hard cap 5000, refused above). Pages the tranche rows only.
- `offset` (integer): Rows to skip before the page (default 0; max 5000). Past the end returns an empty page with `page.total` intact.
- `query` (string, required): Borrower/company name to search (e.g. Finastra, Medline)

### `get_bdc_list` (~221 tokens)

[Tier: free] Roster of the ACTIVE BDCs tracked by Oxford Ledge, sorted by portfolio size -- our coverage, not the whole BDC universe; wound-down issuers are excluded by design. No arguments. Returns {bdcs}; per BDC: ticker, name, listed, holdingCount, totalFairValue (whole USD, latest filing), filingDate, lastParsed and a reconciliation block (reportedTotalFairValue, fairValueBasis, parsedRowSumFairValue, fairValueRefused, fairValueGap, fairValueGapNote). READ fairValueBasis BEFORE using totalFairValue, and fairValueGap with it: an under-counting parse keeps the parsed-row sum, which UNDERSTATES the book. holdingCount, totalFairValue and the arbitration are Oxford Ledge's parse, not filer-published figures. Borrower-keyed counterpart: search_bdc_borrower. Source: SEC EDGAR BDC filings (Oxford Ledge parse). Caveats ride the response's tool_notes. [Requires API mode]

### `get_bdc_borrower_mark_history` (~240 tokens)

[Tier: free] Multi-quarter fair-value mark history for one borrower across every BDC that holds its debt, NEWEST QUARTER FIRST: per-quarter min/max and par-weighted average marks (percent of par, 2dp), holding-row and holder counts, and the contributing BDC tickers. Returns {borrowerNorm, count, quarters, units}. Exact borrower_norm match only -- resolve the key with search_bdc_borrower first. ABOVE-PAR TRAP: a mark above 100 is a par-basis artifact until fair value is checked against cost on the holding rows (get_bdc_holdings), NOT a credit premium. ATTRIBUTION: Oxford Ledge's parse of SEC EDGAR BDC schedules of investments (ol-derived), not a filer-published series. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `borrower_norm` (string, required): Normalized borrower key, matched EXACTLY (take borrowerNorm from a search_bdc_borrower result)
- `quarters` (integer): Most-recent quarters to return (1-16, default 8)

### `get_bdc_holdings` (~332 tokens)

[Tier: free] Full portfolio holdings for one BDC's latest SEC filing: borrower, industry, security type, lien position, rate, maturity, par/cost/fair value and mark per position, plus portfolio-level totals, structure metrics and `topIndustries`. Money is whole USD; marks are percent of par. `totalFairValue` is ARBITRATED: read `fairValueBasis` and `fairValueRefused` first. ABOVE-PAR TRAP: a mark above 100 is a par-basis artifact until fairValue is checked against costAmount, NOT a credit premium. A large book serialises past 100,000 characters: `limit` / `offset` page the `holdings` rows while every total stays computed over the whole book, and nothing is dropped to fit. The totals, structure metrics and arbitration are Oxford Ledge's parse of SEC EDGAR schedule-of-investments filings (10-Q/10-K), not filer-published figures. `ticker` is required. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Max `holdings` rows to return (default 5000 = every row; hard cap 5000, refused above). Pages the row list only.
- `offset` (integer): Rows to skip before the page (default 0; max 5000). Past the end returns an empty page with `page.total` intact.
- `ticker` (string, required): BDC ticker symbol (e.g. ARCC, OBDC — see get_bdc_list)

### `get_debt_maturities` (~284 tokens)

[Tier: plus] Forward debt maturity ladder parsed by Oxford Ledge from the latest 10-K/20-F footnote (the hosted EDGAR-only tool, proxied by name). Returns {ticker, maturities:[{year, amount}], thereafter, confidence, confidence_score, source, validation}. AMOUNTS ARE IN MILLIONS OF USD, not raw dollars -- 400 means $400M. THE LADDER IS AS OF the filing date, not today: the current-year bucket may already be repaid or refinanced. Check `validation` (the balance-sheet cross-check) before quoting a total. confidence / confidence_score / validation are Oxford Ledge's assessment of its own parse; the amounts are the filing's. EDGAR only -- no vendor debt totals and no modelled ladder. For historical issuance/repayment use get_capital_allocation. Source: SEC EDGAR 10-K note extraction. Plus tier: the refusal is AUTH_REQUIRED naming the tier -- keyless, it says the client is anonymous and the operator sets OXFORD_LEDGE_API_KEY; with a valid key on a lower plan, it says THE KEY IS VALID and the plan is what is missing. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `ticker` (string, required): Stock ticker symbol (e.g. AAPL)

### `get_capital_allocation` (~305 tokens)

[Tier: plus] Where a company sent its cash, up to 30 annual labels, from SEC EDGAR XBRL cash-flow tags (the hosted scorecard tool, proxied by name). Returns {ticker, capitalAllocation:{years, periods, dividends, netBuybacks, grossRepurchases, netDebtChange, acquisitions, sharesOut, isDilutive, basis, summary}} as PARALLEL ARRAYS aligned to `years` (newest first, fiscal labels). netBuybacks is a NET, DERIVED DILUTION PROXY, not a buyback figure (repurchases minus issuance, IPO proceeds and SBC); grossRepurchases is the filed line. An IFRS reporter is REFUSED, never served zeros. The net series and the summary are Oxford Ledge derivations over the filed tags (basis hybrid); the inputs are the filing's. Complements get_fundamentals and get_debt_maturities. Source: SEC EDGAR XBRL cash-flow tags, 24h cache. Plus tier: the refusal is AUTH_REQUIRED naming the tier -- keyless, it says the client is anonymous and the operator sets OXFORD_LEDGE_API_KEY; with a valid key on a lower plan, it says THE KEY IS VALID and the plan is what is missing. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `ticker` (string, required): Stock ticker symbol (e.g. AAPL)

### `get_13f_holdings` (~382 tokens)

[Tier: free] What one institutional filer owns: the largest positions in its latest SEC 13F-HR, plus quarter-over-quarter changes. Accepts a numeric CIK (preferred) or a ticker resolved via SEC's company map (BLK; BRK-B or BRK.B for Berkshire). A filer NAME is NOT resolved by this package -- pass the CIK. Returns {cik, fundName, filingDate, periodOfReport, totalHoldings, totalValue, holdings}; each holding is {name, title_of_class, value (whole USD), shares, type, position_type, lots, ticker}. `position_type` is COM|PRN|PUT|CALL: do NOT sum across types. `holdings` is truncated to max_holdings (default 50, cap 500) while the totals cover the whole filing. Source: SEC EDGAR 13F-HR, ~45-day quarterly delay; heavy operation, max 2 concurrent. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `fund` (string, required): Fund CIK number (e.g. 1067983 for Berkshire Hathaway) -- preferred. A ticker is resolved via SEC's company map: letters with at most one class suffix (e.g. BLK, or BRK-B / BRK.B -- SEC lists Berkshir…
- `max_holdings` (integer): Maximum number of holdings to return (default 50, cap 500)

### `get_value_investing_fact` (~238 tokens)

[Tier: free] A value-investing principle, historical fact or attributed paraphrase from Oxford Ledge's curated corpus (~2,000 entries about Buffett, Graham, Munger, Klarman and others). THE WORDING IS NOT VERIFIED against the primary source: none is a verbatim quotation unless `verbatim` is true -- so never present the text as the author's exact words, and credit it with the `attribution` line. Returns a flat fact: {quote, author, source, source_year, category, subcategory, era, difficulty, verbatim, attribution}. Cached 24h per argument set -- vary `category` for a different pick. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `category` (string): Optional category, matched case-insensitively. The vocabulary is EXACTLY: principle, historical_fact, psychology, quote, case_study, contrarian, mistake. An unknown value returns a no-data error -- r…

### `ol_bdc_top_borrowers` (~267 tokens)

[Tier: free] MOAT / BDC discovery: the private-credit borrowers syndicated across the MOST BDCs, ranked by ACTIVE lender count (holder_count_active), then holder_count, then exposure -- the entrypoint for the BDC/private-credit category. Returns {summary, count, borrowers}; each row is {borrower, borrower_norm (the key other ol_bdc_* tools take), holder_count, total_fair_value (whole USD, latest filings), industry}. Feed a borrower_norm into ol_bdc_borrower_dispersion for cross-lender pricing. Caps: limit default 25 / hard 100; min_holders default 2 (max 50). An out-of-range `limit` is REFUSED, never clamped; the `completeness` block is the runtime truth on truncation. Source: SEC EDGAR BDC schedules of investments (Oxford Ledge parse; ol-derived); FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Max borrowers to return (default 25, hard cap 100).
- `min_holders` (integer): Minimum number of BDC lenders a borrower must appear in (default 2).

### `ol_bdc_borrower_dispersion` (~327 tokens)

[Tier: free] MOAT: cross-lender loan-pricing DISPERSION for one private-credit borrower -- how N different BDCs each price the SAME loan (spread / mark / fair value); when one BDC marks a borrower S+550 @ 98 and another S+575 @ 99, the lenders disagree on the credit. Pass the canonical `borrower_norm` (from ol_bdc_top_borrowers or search_bdc_borrower). Returns {summary, borrower_norm, count, lender_count, tranche_count, lenders, ...}: ONE row per BDC lender, widest spread first, tranches nested. UNITS TRAP: `spread` is the raw as-filed number and mixes percent and bps across filers -- compare lenders on `spread_bps` only. Exited positions are excluded by default (include_stale=true shows them). Default 25 lenders, hard cap 100. Source: SEC EDGAR BDC schedules of investments (Oxford Ledge parse; ol-derived); FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `borrower_norm` (string, required): Canonical normalized borrower key (from ol_bdc_top_borrowers or borrower search).
- `include_stale` (boolean): Include lenders whose newest filing no longer names this borrower (stale marks). Default false.
- `limit` (integer): Max LENDERS to return (default 25, hard cap 100); each lender's tranches ride nested.

### `ol_bdc_common_borrowers` (~344 tokens)

[Tier: free] Borrowers common to a GIVEN SET of BDCs -- the cross-portfolio set question ('what do ARCC, OBDC and AGTC all lend to?') in ONE call. Returns per borrower: borrower, borrower_norm, holder_count, holder_tickers, holders ([{ticker, name}]), total_fair_value and total_par_amount in USD, and as_of_oldest/as_of_newest. Each BDC is read at ITS most recent filing, so rows MIX filing dates -- read as_of_range before treating the marks as contemporaneous. Debt positions only. Caps: more than 25 bdc_tickers is REFUSED as INVALID_PARAMS, limit 50/200, min_holders max 50. Feed a borrower_norm to ol_bdc_borrower_dispersion for cross-lender pricing. Source: SEC EDGAR BDC schedules of investments (Oxford Ledge parse -- ol-derived); FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `bdc_tickers` (array, required): BDC symbols to intersect, e.g. ["ARCC","OBDC","AGTC"] (max 25; more than 25 is refused as INVALID_PARAMS, nothing is truncated)
- `limit` (integer): Max borrowers to return (default 50, max 200)
- `min_holders` (integer): Minimum number of the supplied BDCs that must hold the borrower (default 2, min 2 -- this answers what is SHARED; for one BDC's book use ol_bdc_top_borrowers)

### `ol_form_d_raises` (~337 tokens)

[Tier: free] Recent SEC Form D private-placement filings from the SEC's QUARTERLY Form D data set -- newest first, optionally scoped to an industry group and/or a trailing filing-date window. Returns {summary, count, days, industry, offerings}. Amounts are whole USD as disclosed; total_offering_amount is a ceiling, not money raised. The data set lands about one quarter after quarter-end, so a short `days` window is EMPTY BY CONSTRUCTION -- not evidence that nothing was filed. `limit` default 50, hard cap 200. Source: SEC EDGAR Form D data sets (public domain); FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `days` (integer): Trailing filing-date window in days (optional; 1..1825; omit it for the 365-day default -- a value below 1 is refused as INVALID_PARAMS before any request, never widened to the default). The data set…
- `industry` (string): Industry group filter (optional).
- `limit` (integer): Max offerings (default 50, hard cap 200).

### `ol_insider_recent_buys` (~347 tokens)

[Tier: free] Recent OPEN-MARKET insider PURCHASES (SEC code 'P') across the Oxford Ledge issuer catalog (~5.3k tickers) -- a daily insider screen. Returns {summary, since_days, count, buys}, NEWEST FIRST; each buy carries ticker, filing and transaction dates, insiderName, position, shares, pricePerShare, totalValue (USD), url. since_days default 30 (hard cap 180), limit default 25 (hard cap 100). SAMPLING TRAP: when the window holds more purchases than `limit`, you get the NEWEST N filings, not the whole window -- never total these rows and call it the period's insider buying. totalValue and the fallback `position` label are Oxford Ledge derivations (basis hybrid). Source: SEC EDGAR Form 4 (public domain); FREE (no paywall on the hosted channel). Pairs with get_insider_trades (one ticker). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `common_only` (boolean): Common stock only (default true): drops derivative rows and any security title naming preferred / pfd / warrant / debenture / note; Series-named common classes are kept. false restores every open-mar…
- `limit` (integer): Max purchases (default 25, hard cap 100).
- `min_value` (number): Only purchases with totalValue >= this many USD (optional); rows with no plausible filed price are dropped when this is set.
- `since_days` (integer): Trailing window in days (default 30, hard cap 180).

### `get_fails_to_deliver` (~301 tokens)

[Tier: free] SEC fails-to-deliver history for one ticker -- the settlement-failure side of short pressure. Returns {ticker, days, history, count, coverage, as_of, summary}; each row is {date (settlement date), fails (SHARES, not dollars), price (USD), description}, OLDEST-FIRST. `days` (default 180, hard cap 730) is anchored to the latest LOADED settlement date (`as_of`), not to today. An empty or thin history describes the loaded SEC files, not an absence of fails: read `coverage` and `summary` before quoting a window as fail-free. Figures are as SEC published: NOT split-adjusted. Source: SEC Fails-to-Deliver dataset (published twice monthly, ~3-week lag). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `days` (integer): Trailing window in days (default 180, max 730), counted inclusively -- a 90-day window holds 90 settlement dates -- and ending at `as_of` unless end_date is given
- `end_date` (string): ISO date (YYYY-MM-DD) the window ends on; default = the latest loaded settlement date (`as_of`). Pass today's date to measure against the calendar; a future date is clamped to today.
- `ticker` (string, required): Stock ticker symbol (e.g. GME)

### `get_activist_stakes` (~235 tokens)

[Tier: free] Schedule 13D/13G >5% beneficial-owner filings for a ticker -- event-driven stake-building, unlike quarterly 13F. Returns {ticker, count, filings}, newest first, limit default 50 (hard cap 200); rows carry filer_name, filing_date, form_type, shares, percent_of_class, accession_number and is_activist (a FORM-TYPE label: true iff the form is a 13D, not a judgement). `reports_zero` is the filer's own statement that it no longer owns more than 5% -- an exit OR a reporting realignment, so cross-check get_holders before reading it as a sale. FRESHNESS: keyless callers are served STORED rows and never trigger the EDGAR refresh -- read `stale` and `stale_basis`. Source: SEC EDGAR. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Max filings to return (default 50)
- `ticker` (string, required): Stock ticker symbol (e.g. AAPL)

### `ol_treasury_debt` (~234 tokens)

[Tier: free] US Treasury debt composition from the Monthly Statement of the Public Debt. Omit BOTH args for the newest month's full class breakdown; pass security_type AND security_class together for that one class's monthly history (passing only one of them is IGNORED). Returns {summary, rows}. AMOUNTS ARE IN MILLIONS OF USD -- a 28,000,000 value means $28 trillion. The breakdown holds component AND Total rows, so summing a column double-counts. `limit` (series only) default 120 months, hard cap 360. Sibling of get_yield_curve. Source: Treasury.gov MSPD (public domain); FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Monthly points for a series (default 120, hard cap 360).
- `security_class` (string): Class within the type; '_' for Total rows.
- `security_type` (string): e.g. 'Total Public Debt Outstanding' (with security_class for a series).

### `ol_cftc_cot` (~316 tokens)

[Tier: free] CFTC Commitments-of-Traders positioning for THREE curated markets (keys gold, crude_oil, sp500). Pass `market` for its weekly history, NEWEST FIRST (names are normalised: 'wti', 'GOLD', 'e-mini s&p' resolve), or omit it for the latest report across the three. Returns {summary, market, matched_market, rows}. mm_* and open_interest are CONTRACT counts, not dollars, and mm_* cover ONE speculative category per report family (Managed Money for gold and crude_oil, Leveraged Funds for sp500). `limit` (series only) default 52, hard cap 156. Source: CFTC.gov (public domain); FREE (no paywall on the hosted channel). ATTRIBUTION: every field is CFTC verbatim EXCEPT market_key and market_label (Oxford Ledge's curated market catalog), matched_market and candidates (Oxford Ledge's resolver over that catalog) and mm_net (mm_long minus mm_short, computed by Oxford Ledge). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Weekly reports for a market series (default 52, hard cap 156).
- `market` (string): Market key, CFTC report name or desk symbol -- gold / GC / XAU, crude_oil / CL / WTI, sp500 / ES / S&P (case-insensitive; omit for the latest all-market snapshot).

### `ol_fdic_bank` (~267 tokens)

[Tier: free] FDIC-insured banks and thrifts. Pass `query` for a name PREFIX search against ACTIVE institutions (largest-asset first), or omit it for the largest active institutions. Returns {summary, query?, institutions}, each {cert, name, stname, city, bkclass, active, asset, dep, estymd, webaddr, ticker, repdte}. UNITS: `asset` and `dep` are THOUSANDS of dollars. The store is loaded ACTIVE-ONLY, so a bank that merged away or failed is absent by construction -- an empty search is a fact about the loaded store, never about the world. `limit` default 25, hard cap 100. Source: FDIC.gov (public domain); FREE (no paywall on the hosted channel). ATTRIBUTION: every field is FDIC BankFind verbatim EXCEPT `ticker`, which is an Oxford Ledge-verified CERT-to-ticker mapping, not an FDIC-published field. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Max institutions (default 25, hard cap 100).
- `query` (string): Institution name prefix (omit for the top-by-assets list).

### `ol_federal_contracts` (~258 tokens)

[Tier: free] Federal-contract obligation history for a ticker, OR the fiscal-year leaderboard -- for government-revenue-dependence diligence. TWO SHAPES: one of `ticker` or `fiscal_year` is REQUIRED (if both, `ticker` wins). With `ticker`: per-fiscal-year obligations (USD, the ten largest recipients, dropped_unresolved), NEWEST FY FIRST; with fiscal_year only: a leaderboard, largest first. A fiscal year still in progress is PARTIAL (period_complete false) and year-to-date -- never compare it to a full year. Obligations are federal awards, not company-reported revenue. `limit` default 20, hard cap 100. Source: USAspending.gov (public domain; OL ticker-crosswalked); FREE (no paywall on the hosted channel). Attributing awards to a ticker is an Oxford Ledge curated crosswalk. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `fiscal_year` (integer): Fiscal year for the top-contractors leaderboard.
- `limit` (integer): Max rows (default 20, hard cap 100).
- `ticker` (string): Stock ticker (omit for the FY leaderboard).

### `ol_patents` (~229 tokens)

[Tier: free] Recent USPTO patent filings for a ticker (innovation-intensity diligence). Returns {summary, ticker, count, filings}, NEWEST FIRST; `limit` default 50, hard cap 200, so this is a recent slice, never a full portfolio, and `count` is the number RETURNED. TRAP: a non-empty patent_number marks a continuation of an already-granted PARENT, NOT a grant of this application -- read the status field. Filings reflect Oxford Ledge's last on-demand USPTO ingest for the ticker, not a schedule. Source: USPTO (public domain); FREE (no paywall on the hosted channel). ATTRIBUTION: every filing field is USPTO ODP verbatim EXCEPT `ticker`, which is an Oxford Ledge applicant-name resolution, not a USPTO field. Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `limit` (integer): Max filings (default 50, hard cap 200).
- `ticker` (string, required): Stock ticker (e.g. GOOGL).

### `ol_bdc_mark_changes` (~325 tokens)

[Tier: free] MOAT / private credit: the largest quarter-over-quarter MARK moves across a SET of BDC portfolios -- 'which borrowers got marked up or down the most last quarter, and by whom' in ONE deterministic call. Returns {increases, decreases}, each a global ranking; each row is {borrower, portfolio, prior_mark, latest_mark, mark_delta, prior_filing, latest_filing}. Marks are percent of par, fair-value-weighted across the BDC's tranches; mark_delta is in points. A borrower enters only when |mark_delta| >= 1.0 point and its fair value is >= $500k, so 'no moves' can hide small drifts. `coverage` names every BDC that was NOT read and why. bdc_tickers capped at 25; limit default 10 / hard 50 per direction. ATTRIBUTION: Oxford Ledge's parse of SEC EDGAR BDC schedules of investments (ol-derived), not a filer-published series; FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `bdc_tickers` (array, required): BDC symbols to compare, e.g. ["ARCC","FSK","OBDC"] (max 25; the excess is reported in `coverage.not_covered_detail` rather than dropped)
- `limit` (integer): Rows per direction (default 10, hard cap 50). Ranking is GLOBAL across the supplied portfolios, not per BDC.

### `ol_bdc_credit_quality` (~272 tokens)

[Tier: free] BDC non-accrual credit-deterioration signal: the share of debt fair value on non-accrual (loans that stopped paying) in the latest filing, plus the trailing-quarter trend. Returns {summary, ticker, latest, trend}; `trend` is OLDEST-FIRST. flagged_pct is a percentage over the DETERMINATE-flag denominator, never total_debt_fv, and it is deliberately NULL (withheld, never zero) when determinate coverage is under 90% of debt fair value or the flag rate looks like a parse misread -- read `coverage_state` before reading flagged_pct. `quarters` default 12, hard cap 24. Pairs with ol_bdc_borrower_dispersion and ol_bdc_top_borrowers. ATTRIBUTION: Oxford Ledge's parse of SEC EDGAR BDC schedules of investments (ol-derived), not a filer-published series; FREE (no paywall on the hosted channel). Caveats ride the response's tool_notes. [Requires API mode]

Input parameters:

- `quarters` (integer): Trailing quarters of trend (default 12, hard cap 24).
- `ticker` (string, required): BDC ticker (e.g. ARCC, ORCC, FSK).

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/oxford-ledge-mcp#diagnostics

## Score history

- 2026-09-30: 61
- 2026-09-29: 76
- 2026-09-28: 61
- 2026-09-27: 66

## Common questions

### What is the Oxford Ledge MCP server?

Oxford Ledge is an MCP server listed in the public MCP registry as com.oxfordledge/oxford-ledge. Ask your assistant; it reads the public record: SEC filings, 13F, insider trades, BDC loans. This page covers its PyPI package (oxford-ledge-mcp).

### Is the Oxford Ledge MCP server safe to use?

Oxford Ledge scores 61 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 30 September 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Oxford Ledge MCP server expose?

Oxford Ledge exposes 29 tools: get_holders, get_sec_filings, get_insider_trades, get_fundamentals, get_yield_curve, and 24 more. Their descriptions and schemas cost roughly 8,163 tokens of context every time the server is loaded.

### Is the Oxford Ledge MCP server still maintained?

Oxford Ledge is still listed as active in the MCP registry. We last reached this channel on 30 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Oxford Ledge MCP server under?

Oxford Ledge declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/oxford-ledge-mcp/
- Socket report: https://socket.dev/pypi/package/oxford-ledge-mcp
- Repository: https://github.com/hs902/oxford-ledge-mcp
- Website: https://www.oxfordledge.com/mcp
- Changelog RSS feed: https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/oxford-ledge-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/oxford-ledge-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-oxfordledge-oxford-ledge/oxford-ledge-mcp