# Priorcase (remote · priorcase.com)

Past moments that look like now with what followed each, and every CPI and FOMC with its outcome.

- Trust score: 65/100 (medium)
- Change this week: +29
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `priorcase.com`: 65/100 (this document), [markdown](https://verifymcp.io/servers/com-priorcase-priorcase/priorcase.md), [page](https://verifymcp.io/servers/com-priorcase-priorcase/priorcase)

## Channel facts

- Endpoint: `https://priorcase.com/mcp/`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.1`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, 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-11-05.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 11 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 62/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 2914 tokens (~264/item across 11 items; 11 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **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 11 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 12 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Priorcase MCP server?

Priorcase is a hosted endpoint at https://priorcase.com/mcp/, so there is nothing to install locally. 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 --transport http com-priorcase-priorcase 'https://priorcase.com/mcp/'
```

### Cursor

```json
{
  "mcpServers": {
    "com-priorcase-priorcase": {
      "url": "https://priorcase.com/mcp/"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-priorcase-priorcase": {
      "type": "http",
      "url": "https://priorcase.com/mcp/"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-priorcase-priorcase]
url = "https://priorcase.com/mcp/"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-priorcase-priorcase": {
      "type": "remote",
      "url": "https://priorcase.com/mcp/",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-priorcase-priorcase --url 'https://priorcase.com/mcp/' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-priorcase-priorcase:
    url: "https://priorcase.com/mcp/"
```

### Netclaw

```json
{
  "McpServers": {
    "com-priorcase-priorcase": {
      "Transport": "http",
      "Url": "https://priorcase.com/mcp/"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-priorcase-priorcase -t streamable-http -u 'https://priorcase.com/mcp/'
```

### Other

```json
{
  "mcpServers": {
    "com-priorcase-priorcase": {
      "type": "http",
      "url": "https://priorcase.com/mcp/"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## 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-11-05 (score 65, +1)

- [functional improvement] Stability: unverified → 0.03

### 2026-11-04 (score 64, +28)

- [security regression] Authorization: fail → unverified
- [security improvement] Transport: unverified → pass
- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Tool coverage: unverified → 100
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 100

### 2026-10-13 (score 36)

First indexed and scored.

## MCP tools (11)

### `get_started` (~110 tokens)

Start here

Start here. Returns what this server answers and which tool answers which question — find_analogs for a moment, get_topic_outcomes for a kind of recurring event, query_history for a condition, get_market_state for one moment, get_price_paths to draw them together — what the two rules mean for how you read any reply, and what can be asked without a key. It carries the live coverage that list_coverage returns, so one call is enough to begin. Takes no arguments and costs nothing.

### `find_analogs` (~449 tokens)

Find analogous moments

Find the past moments whose price shape most resembles a given one, each with the path that followed it. Reach for this when what you hold is a moment and what you want is other moments shaped like it. If what you hold is a condition you can state, use query_history; if it is a kind of recurring event, use get_topic_outcomes; if you already have the moments and only want their paths drawn together, use get_price_paths. Matching is done by a model of ours: it reads the shape of the move before a moment rather than its level, so a quiet stretch can match a violent one and two moments thousands of dollars apart can be alike. Matches come back one by one and are never averaged; the spread between them is the answer. Each is point-in-time — what it reports was knowable at that moment, and what came after is labelled as having followed. Read the `quality` field before reading anything into the set. `asset` takes a symbol from list_coverage. `at` is a UTC ISO-8601 moment inside that asset's range; omit it to search from now. `k` is how many moments come back, and a call costs one answer for every ten of them. `scale` only sets the window the paths are drawn at — it does not change which moments are found. An asset kept at one value a day — list_coverage's `searched` says which — is matched and drawn on that one value, so the path after a moment is a bar or two rather than a curve and `quality.range_median_pct` comes back near zero. Read it before making anything of such a set.

Input parameters:

- `asset` (string): Asset symbol, e.g. BTC. list_coverage lists them.
- `at`: UTC moment to search from, ISO 8601. Omit for now.
- `k` (integer): How many past moments to return. One answer per ten.
- `scale` (string): Window the paths are drawn at. One of 5m, 15m, 30m, 1h, 2h, 4h, 1d

### `query_history` (~336 tokens)

Find when a condition was true

Find every past moment a condition was true, newest first, each with what was knowable then and the path that followed. Reach for this when the condition can be stated; to search by the shape of the move instead, use find_analogs. A condition is one fact the bars can answer, written in words: the price level ('under 100k', 'above 7,000'), a move over an hour, a day or three days ('fell 10% in a day', 'rose 5% in an hour'), how far below the 7-day high ('20% below its high'), or how loud the day was against its month ('this volatile', 'quiet'). 'crashed' and 'rallied' are read as a 10% day. The wording around those facts is free; the facts are not — anything else comes back refused with the list rather than guessed at, and list_coverage carries the same list. The response carries how the condition was understood, so the reading can be checked before the moments are trusted. A run of bars that all meet the condition counts once, at the first, and every value is measured on bars that had closed by that moment. `asset` takes a symbol from list_coverage. A call costs one answer for every ten moments.

Input parameters:

- `asset` (string): Asset symbol, e.g. BTC. list_coverage lists them.
- `limit` (integer): How many moments to return. One answer per ten.
- `q` (string, required): The condition, in words, e.g. 'fell 10% in a day'

### `get_market_state` (~185 tokens)

Read the market at a moment

Read what the market was at one moment and what happened after it: returns over 1h, 24h, 7d and 30d, the day's high, low and volume, how volatile it was against its own month, and the drawdown from the week's high. Use this for one moment's numbers; for the price path around a moment, or around several at once, use get_price_paths. Everything under `then` was already knowable at that moment — nothing later leaks into it — and what followed is labelled as having followed. `at` is a UTC ISO-8601 moment inside the asset's range, which list_coverage gives. One call costs one answer.

Input parameters:

- `asset` (string): Asset symbol, e.g. BTC. list_coverage lists them.
- `at` (string, required): UTC moment, ISO 8601

### `get_price_paths` (~276 tokens)

Draw the paths around moments

Draw the price path around one or more moments, as percent from the close at each, so paths of different sizes can be laid over one another. Reach for it when you already hold the moments — from any of the searches — and want their paths side by side. For one moment's summary numbers, use get_market_state; to find the moments in the first place, use find_analogs, query_history or get_topic_outcomes. Offsets are minutes from that moment: negative before it, positive after. A moment still inside the present has no `after`. `at` takes up to 24 UTC ISO-8601 moments in one call. `scale` sets how far back each path reaches, `after_minutes` how far past each moment it reads. `asset` takes a symbol from list_coverage.

Input parameters:

- `after_minutes` (integer): How far past each moment to read, in minutes
- `asset` (string): Asset symbol, e.g. BTC. list_coverage lists them.
- `at` (array, required): UTC moments, ISO 8601, up to 24
- `scale` (string): How far back each path reaches. One of 5m, 15m, 30m, 1h, 2h, 4h, 1d

### `list_coverage` (~130 tokens)

List what can be asked about

List what this server can answer about: every asset with the name and aliases it answers to, where its data comes from, the first moment held and how far each scale reaches; the scales themselves; and the condition phrasings query_history reads. Call this before guessing a symbol, a scale, a date range or a phrasing — the other tools refuse what falls outside it, and the aliases are how 'bitcoin' or 'xbt' becomes a symbol. For the kinds of recurring event the data is indexed by, use list_topics instead. Takes no arguments. One call costs one answer.

### `list_topics` (~140 tokens)

List the kinds of recurring event

List the kinds of recurring event the data is indexed by — CPI releases, FOMC statements, rate cuts and holds, halvings, exchange failures — each with its slug and how many of them are held. Use this to find the slug for get_topic_outcomes; for a single dated event rather than a kind, use list_events, and for a moment that is not an event at all, use find_analogs or query_history. `q` narrows the list to labels carrying those words; omit it for all of them. One call costs one answer.

Input parameters:

- `q`: Words the label must carry. Omit for every topic.

### `get_topic_outcomes` (~284 tokens)

Read what followed every event of a kind

List every past event of one kind — every CPI release, every FOMC statement — each with what was knowable at that moment and the path that followed it. This is the tool for 'what happened the last N times this happened'. Reach for it when what you hold is a kind of event rather than a moment or a condition. Take `topic` from list_topics; for one dated event on its own, use list_events. Newest first. Pass `alike` — a UTC ISO-8601 moment, or 'now' — to rank that same list by how much each one resembled that moment instead, so 'of every past FOMC, the ones that looked like now' is one call; each item then carries that number, measured by the same model find_analogs uses. Outcomes come back one by one and are never averaged, and every member of the kind stays in the list even when it cannot be ranked. `asset` takes a symbol from list_coverage.

Input parameters:

- `alike`: Rank by likeness to this UTC moment (ISO 8601, or 'now') instead of by date.
- `asset` (string): Asset symbol, e.g. BTC. list_coverage lists them.
- `topic` (string, required): The topic's slug, as list_topics gives it, e.g. cpi

### `list_events` (~327 tokens)

List dated events

List dated events the data is indexed by — CPI releases, FOMC statements, options expiries — each with the moment it became known, the source it is taken from and the topics it belongs to. Use this to find or date a single event; for every event of a kind together with what followed each, use get_topic_outcomes. By default it lists events already known, newest first. Set `upcoming` to list what is scheduled ahead instead, soonest first and counted from the end of the data: a calendar is public in advance but what a release will say is not, so an event still ahead carries only its kind — that an FOMC statement is due, not what it will decide. `q` matches words in the name or aliases, `kind` is one of fomc, cpi, crypto, macro or market, and `since`/`until` bound when an event became known. `days` applies only when `upcoming` is set. One call costs one answer.

Input parameters:

- `days` (integer): How far ahead to look, in days. Only with upcoming.
- `kind`: fomc, cpi, crypto, macro or market
- `limit` (integer): How many events to return
- `q`: Words the name or aliases must carry
- `since`: Known at or after this UTC moment, ISO 8601
- `until`: Known at or before this UTC moment, ISO 8601
- `upcoming` (boolean): List what is scheduled ahead instead of what is known

### `compare_assets` (~222 tokens)

Read every asset at a moment

Read what every asset was doing at the same moment, side by side: the close, the day and three-day returns, the shape of the move before it and the path after, for each one. Reach for it when the question is about the surroundings of a moment rather than the one asset — what the dollar, the yields and oil were doing while bitcoin did that. For one asset at one moment in more detail, use get_market_state. `at` takes up to 24 UTC ISO-8601 moments and every asset is read at each of them, so one call compares moments as well as assets. Everything reported was knowable at that moment. `window_minutes` is how far back each shape reaches and `after_minutes` how far past the moment it runs; left out, they take the same defaults the searches draw at.

Input parameters:

- `after_minutes`: How far past each moment to read
- `at` (array, required): UTC moments, ISO 8601, up to 24
- `window_minutes`: How far back each shape reaches

### `get_bars` (~328 tokens)

Get the raw bars

Get the bars themselves — open, high, low, close and volume at a fixed step — for a stretch of time. Reach for it when the tools above do not shape the data the way you need it: your own measure, your own chart, a window none of them draw. For a moment read against its own history, use get_market_state; for the path around moments as percent from each, use get_price_paths, which is what the searches compare on. `asset` takes a symbol from list_coverage and `step` one of its scales — an asset kept at one value a day has only `1d`. `since` and `until` are UTC ISO-8601 bounds; left out, the whole history at that step comes back, and a stretch too long to serve is refused in those words rather than truncated quietly, so narrow it or take a longer step. BTC at `1d` is about five thousand bars and comes back whole; BTC at `1h` needs a `since`. Nothing later than the end of the data is returned, so a window running into the present ends where the data does.

Input parameters:

- `asset` (string): Asset symbol, e.g. BTC. list_coverage lists them.
- `since`: From this UTC moment, ISO 8601
- `step` (string): Bar size. One of 5m, 15m, 30m, 1h, 2h, 4h, 1d
- `until`: To this UTC moment, ISO 8601

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-priorcase-priorcase/priorcase#diagnostics

## Score history

- 2026-11-05: 65
- 2026-11-04: 64
- 2026-11-03: 36
- 2026-11-02: 36
- 2026-11-01: 36
- 2026-10-31: 36
- 2026-10-30: 36
- 2026-10-29: 36
- 2026-10-28: 36
- 2026-10-27: 36
- 2026-10-26: 36
- 2026-10-25: 36
- 2026-10-24: 36
- 2026-10-23: 36
- 2026-10-22: 36
- 2026-10-21: 36
- 2026-10-20: 36
- 2026-10-19: 36
- 2026-10-18: 36
- 2026-10-17: 36
- 2026-10-16: 36
- 2026-10-15: 36
- 2026-10-14: 36
- 2026-10-13: 36

## Common questions

### What is the Priorcase MCP server?

Priorcase is an MCP server listed in the public MCP registry as com.priorcase/priorcase. Past moments that look like now with what followed each, and every CPI and FOMC with its outcome. This page covers its hosted endpoint (https://priorcase.com/mcp/).

### Is the Priorcase MCP server safe to use?

Priorcase scores 65 out of 100 on VerifyMCP. 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 Priorcase MCP server expose?

Priorcase exposes 11 tools: get_started, find_analogs, query_history, get_market_state, get_price_paths, and 6 more. Their descriptions and schemas cost roughly 2,787 tokens of context every time the server is loaded.

### Does the Priorcase MCP server require authentication?

No. We connected to Priorcase without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Priorcase MCP server still maintained?

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

## Links

- Remote endpoint: https://priorcase.com/mcp/
- Authorisation metadata: https://priorcase.com/.well-known/oauth-protected-resource/mcp
- Website: https://priorcase.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-priorcase-priorcase/priorcase.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-priorcase-priorcase/priorcase.json
- HTML version of this page: https://verifymcp.io/servers/com-priorcase-priorcase/priorcase