# Skeletable (remote · skeletable.com)

Source-backed public tables with citations, claim checks, and reviewable corrections.

- Trust score: 68/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

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

## Channel facts

- Endpoint: `https://skeletable.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## 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**: 11/100
  - TLS not yet verified: we couldn't open a connection to check the certificate.
  - Authorisation not yet verified: we couldn't confirm whether this endpoint requires it.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS not yet verified: we couldn't read the response headers to check for it.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 0/100
  - Transport check failed: declared streamable-http, but we couldn't connect to verify it.
- **Schema Quality & AI Usability**: 0/100
  - Schema not yet verified: we couldn't read the endpoint's schema, or could read only part of its tool list.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 0/100
  - Tool coverage not yet verified: we couldn't read the endpoint's tools, or could read only part of the list.
- **Tool Safety**: 0/100
  - Tool safety not yet verified: we couldn't read the endpoint's tools, or could read only part of the list.
- **Capabilities**: 0/100
  - Capabilities not yet verified: we couldn't read the endpoint's capabilities.

**Unverified: 5 categories.** Categories scored 0 because we could not verify them: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm.

## Install

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

Skeletable is a hosted endpoint at https://skeletable.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 eftpmc-skeletable 'https://skeletable.com/mcp'
```

### Cursor

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

### VS Code

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

### Codex

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

### opencode

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

### OpenClaw

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

### Hermes

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

### Netclaw

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

### Vellum

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

### Other

```json
{
  "mcpServers": {
    "eftpmc-skeletable": {
      "type": "http",
      "url": "https://skeletable.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-04 (score 68, 0)

- [security regression] Endpoint reachability: reachable → unreachable
- [security regression] HSTS header: fail → unverified
- [security regression] Stability: 0.07 → unverified
- [security regression] Authorization: partial → unverified
- [security regression] Tool safety: pass → unverified
- [security regression] TLS certificate: pass → unverified
- [security regression] Transport: pass → fail
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified

### 2026-11-02 (score 68, −1)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “add_rows” rewrote its description, which is the text the model reads
- [security] Tool “create_table” rewrote its description, which is the text the model reads
- [security] Tool “fill_cells” rewrote its description, which is the text the model reads
- [security] Tool “get_table” rewrote its description, which is the text the model reads
- [functional regression] Schema quality: 130 → 181
- [functional improvement] Stability: unverified → 0.03
- [functional] New tool “data_link”
- [functional] New tool “export_table”
- [functional] New tool “fill_ai_cells”
- [functional] New tool “fork_table”
- [functional] New tool “next_ai_cells”
- [functional] New tool “save_version”
- [functional] New tool “set_instruction”
- [cosmetic] “create_table” added an optional parameter “proof”
- [cosmetic] “create_table” added an optional parameter “template”
- [cosmetic] “get_table” added an optional parameter “limit”
- [cosmetic] “get_table” added an optional parameter “offset”
- [cosmetic] “get_table” added an optional parameter “version”
- [cosmetic] “create_table” reworded the description of “columns”
- [cosmetic] “create_table” reworded the description of “rows”
- [cosmetic] “create_table” reworded the description of “title”
- [cosmetic] “create_table” made “columns” optional
- [cosmetic] “create_table” made “rows” optional
- [cosmetic] “create_table” made “title” optional

### 2026-11-01 (score 69)

First indexed and scored.

## MCP tools (16)

### `list_tables` (~59 tokens)

Find tables in the library. Each result gives its slug, the question it answers, its size and when it was last read.

Input parameters:

- `query` (string): Words to look for in titles, questions, columns and rows. Leave out to list everything.

### `get_table` (~169 tokens)

Read a table: its scope, its columns with the rule for each, a summary of what each column holds, and its rows. A null value is blank. `origins` says where a row's unquoted values came from, `ai` says how far each AI column has got, and `versions` lists saved versions. For a big table, read the summaries first and page through rows with `offset` and `limit`.

Input parameters:

- `limit` (integer): Return at most this many rows. 0 returns just the table's shape and summaries
- `offset` (integer): Skip this many rows
- `slug` (string, required): From list_tables
- `version` (integer): A saved version's number, from `versions` in get_table. Leave out for the live table

### `get_cell` (~173 tokens)

The evidence for one value: the source, the exact quote, what kind of source it is and when it was read. For a missing value, where we looked, and `absent` means the source was read and gives no such value. `url` is the cell's lasting address, showing its proof, for citing. `confirmed` says how a second reader backed it up, and without it the value has been read once. `conflicts` lists sources that state something else, `history` lists past values, and `watch` says whether the quote was still on its page at the last check.

Input parameters:

- `column` (string, required): The column's id, from get_table
- `row` (string, required): The row's key, from get_table
- `slug` (string, required): From list_tables

### `check_claim` (~156 tokens)

Test a statement against one cell, such as whether a value in a draft or an answer is right. The verdict is `matches`, `differs` (with what the source states), `disputed` (sources disagree, see `conflicts`) or `unknown` (no acceptable source stated it, so say so). It compares values and doesn't judge meaning, so read the quote before relying on a text verdict. Use list_tables and get_table to find the cell first.

Input parameters:

- `column` (string, required): The column's id, from get_table
- `row` (string, required): The row's key, from get_table
- `slug` (string, required): From list_tables
- `value` (string, required): The value being claimed

### `export_table` (~188 tokens)

A table as CSV, ready to save as a file or load into a notebook. The first column is each row's name unless `names` is false. `columns` picks columns by id, in that order. With `proof`, each column is followed by its source and quote, and in a table whose proof is optional, by where each value came from. An empty field means no value.

Input parameters:

- `columns` (array): Column ids, from get_table. Leave out for every column
- `names` (boolean): Whether to start each line with the row's name. Defaults to true
- `proof` (boolean): Whether to add each value's source, quote and origin. Defaults to false
- `slug` (string, required): From list_tables
- `version` (integer): A saved version's number, from `versions` in get_table. Leave out for the live table

### `propose_change` (~146 tokens)

Suggest a new value for a cell, with its proof. The quote must be word for word from the source and state the value. The owner reviews it before anything changes. Needs a token sent as a Bearer token.

Input parameters:

- `column` (string, required): The column's id, from get_table
- `note` (string): Why this should change
- `quote` (string, required): The exact words on that page
- `row` (string, required): The row's exact key, from get_table
- `slug` (string, required): From list_tables
- `source` (string, required): The page that states it
- `value` (string, required): The new value, following the column's rule

### `create_table` (~391 tokens)

Make a private draft table, ready to fill, for anything from a tracker to a dataset. Its values say where they came from unless you set `proof` to `required`. Only `title`, `columns` and `rows` are needed now, but give `question`, `scope`, and a `rule` for each column if you can: a person has to supply them before publishing. Returns the column ids fill_cells needs, and the sheet's link, so tell your person to open it and watch it fill. Needs a token.

Input parameters:

- `columns` (array): Needed unless you use a template
- `owner` (string): A team you're on. Leave out for your own account
- `proof` (string): `optional` (the default): each value says where it came from, like a person, a file, an email or a page. `required`: every value must quote a source word for word, for a table of public facts
- `question` (string): The question the table answers
- `rows` (array): Row names. To add rows with their values, use add_rows after
- `scope` (string): What belongs in the table and what doesn't
- `template` (string): Start from a template, with its columns set up: `job-tracker` (Every application, where it stands and what's next, kept current from your email), `text-dataset` (Labeled examples to train or test a c…
- `title` (string): Needed unless you use a template
- `topic` (string): A broad subject, like Law or Consumer tech

### `add_columns` (~52 tokens)

Add columns to a draft you run, such as a blank one a person started. Returns the new column ids for fill_cells. Needs a token.

Input parameters:

- `columns` (array, required)
- `slug` (string, required)

### `add_rows` (~191 tokens)

Add up to 500 rows to a table you run. Each row is a name, or an object with its `values` by column id or label, so a whole tracker or dataset goes in a few calls. A row without a `key` gets the next free number. A name the table already has gets the values given for it, so syncing again from the same source is one call; with no values it's skipped. Say where the values came from with `origin` (`entered`, `imported` with a `note` naming the file or email, `link` with a `source`, or `generated`, which is the default without a source). Rows with values can go into a published table too; rows by name only into a draft. A table that requires proof takes rows by name only. Needs a token.

Input parameters:

- `rows` (array, required)
- `slug` (string, required)

### `fill_cells` (~266 tokens)

Set up to 200 cells of a table you run. Usually a cell gives `value` and `origin` (`entered`, `imported` with a `note` like the file or email it came from, `link` with its `source`, or `generated`). Left out, the origin is `link` when there's a `source` and `generated` when there isn't. These can go into a published table too, and never replace a quoted value. A date is written YYYY-MM-DD, and a column with choices takes only one of them. In a table that requires proof, a cell instead gives `value`, `source` and `quote`, word for word from the source; each page is opened before it's saved, so send at most 25 of these at once, and only into a draft. If no acceptable source states it, give `checked` with the pages you read, and `none_stated` only if you read the whole source and it has no such value. The reply counts what saved and lists only the cells that didn't, with a reason, and `unchecked` names quoted values whose page couldn't be read. Needs a token.

Input parameters:

- `cells` (array, required)
- `slug` (string, required): From create_table or list_tables

### `data_link` (~102 tokens)

A private address that loads a table you run as CSV, for a notebook, a script or a spreadsheet, with the lines to do it. Add `?columns=a,b` to pick columns and `?names=0` to leave out row names. Anyone with the link can read the data, and `fresh` makes a new one so the old one stops working. Needs a token.

Input parameters:

- `fresh` (boolean)
- `slug` (string, required)

### `save_version` (~76 tokens)

Freeze a table you run as it stands now, as a numbered version with a lasting link that never changes. Do this before training on a dataset or citing a table, and name the version you used. Needs a token.

Input parameters:

- `note` (string): What this version is, like "Before review"
- `slug` (string, required)

### `fork_table` (~107 tokens)

Copy a table into your own account as a private draft, to extend or relabel: any published public table, or one you run. Every value keeps its proof or origin, and the copy remembers where it came from. Needs a token.

Input parameters:

- `owner` (string): A team you're on. Leave out for your own account
- `slug` (string, required): owner/slug, from list_tables
- `title` (string): A title for the copy. Defaults to the original's

### `set_instruction` (~125 tokens)

Make a column an AI column, change its instruction, or turn it back into a plain column with an empty one. The instruction says what to work out for each row and names other columns in braces, like "Classify {Pitch} by genre". Its values never overwrite what a person typed, linked or quoted. Needs proof to be optional and a token.

Input parameters:

- `choices` (array): For a text column, the only answers it takes
- `column` (string, required): The column's id or label
- `instruction` (string, required)
- `slug` (string, required)

### `next_ai_cells` (~139 tokens)

The next prompts to answer for a table's AI columns, up to 200 at a time: blank cells first, then answers whose row or instruction has changed. Answer each prompt yourself, then send the answers back with fill_ai_cells, each with its `row` and `basis`. Repeat until it says `done`. `redo` also re-answers generated values that came from outside the instruction. Needs a token.

Input parameters:

- `column` (string): One AI column's id or label. Leave out for the first one with work waiting
- `limit` (integer)
- `redo` (boolean)
- `slug` (string, required)

### `fill_ai_cells` (~125 tokens)

Save up to 200 answers to an AI column, each with the `row` and `basis` next_ai_cells gave it. An answer outside the column's choices, or to a prompt that has since changed, comes back with a reason. Each value is saved as generated, with the instruction and `model`. Needs a token.

Input parameters:

- `answers` (array, required)
- `column` (string, required): The AI column's id, from next_ai_cells
- `model` (string, required): The model that answered, like the one you are
- `slug` (string, required)

## Diagnostics

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

## Score history

- 2026-11-05: 68
- 2026-11-04: 68
- 2026-11-03: 68
- 2026-11-02: 68
- 2026-11-01: 69

## Common questions

### What is the Skeletable MCP server?

Skeletable is an MCP server listed in the public MCP registry as io.github.eftpmc/skeletable. Source-backed public tables with citations, claim checks, and reviewable corrections. This page covers its hosted endpoint (https://skeletable.com/mcp).

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

Skeletable scores 68 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 Skeletable MCP server expose?

Skeletable exposes 16 tools: list_tables, get_table, get_cell, check_claim, export_table, and 11 more. Their descriptions and schemas cost roughly 2,465 tokens of context every time the server is loaded.

### Does the Skeletable MCP server require authentication?

Its publisher declares no required credentials for Skeletable. We have not been able to confirm that against the live endpoint, and a server can require authorisation without declaring it here.

### Is the Skeletable MCP server still maintained?

Skeletable is still listed in the MCP registry, though our most recent checks did not reach this channel. We last reached this channel on 3 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://skeletable.com/mcp
- Repository: https://github.com/eftpmc/skeletable
- Website: https://skeletable.com/developers
- Changelog RSS feed: https://verifymcp.io/servers/eftpmc-skeletable/skeletable.xml
- Changelog JSON feed: https://verifymcp.io/servers/eftpmc-skeletable/skeletable.json
- HTML version of this page: https://verifymcp.io/servers/eftpmc-skeletable/skeletable