# JustClaw-It MCP documentation (full text)

Source: https://justclaw.it.com/docs. Generated from the live docs; each section below is one page.

---

URL: https://justclaw.it.com/docs

# JustClaw-It MCP documentation

JustClaw-It is a remote MCP server for coding agents. Your agent searches 1,459,705 licence-cleared components mined from real open-source repositories, then pulls the one it wants: full source, a GitHub permalink, the SPDX licence, the copyright holder and an attribution header to keep with the code.

- **Search is free.** `find_similar`, `library_stats`, `list_categories`, `list_licenses`, `search_components` cost 0 credits (an API key is still required, and searches are rate-limited).
- **A pull costs 1 credit.** `get_component` returns the source. The Pro tools cost more (3 and 10 credits).
- **Plans:** Free ($0: 30 credits on day one, then 10 a day), Solo $10/month, Indie $19/month, Pro $49/month. Every plan is a hard cap: nothing is ever billed beyond the plan price (plus any sales tax shown at checkout).
- **Licence and attribution travel with every component**, and the public library only serves permissive and weak-copyleft code.

New here? Start with the [Quickstart](/docs/quickstart).

## Quickstart

1. [Get a free API key](/signup) (email only, no card).
2. Run the installer on the machine your agent runs on:

```sh
npx @justclaw-it/cli init
```

or, without npm on your PATH:

```sh
curl -fsSL https://justclaw.it.com/install | sh
```

The CLI checks your key with a live `tools/list` call, finds the agents on your machine and adds the `justclaw-it` server to each, backing up every file it edits first. Restart your agent and ask: *"search JustClaw-It for a stripe checkout handler"*. Details: [CLI](/docs/cli). Prefer to edit config by hand? See the client setup below.

## Client setup (manual)

Server URL `https://justclaw.it.com/mcp` (Streamable HTTP), header `Authorization: Bearer <YOUR_API_KEY>`. Replace `<YOUR_API_KEY>` with your key. Each client also has its own page with verification steps: [Claude Code](/docs/clients/claude-code), [Claude Desktop](/docs/clients/claude-desktop), [Cursor](/docs/clients/cursor), [Windsurf](/docs/clients/windsurf), [VS Code](/docs/clients/vscode), [Codex](/docs/clients/codex), [OpenClaw](/docs/clients/openclaw), [Hermes Agent](/docs/clients/hermes), [other clients](/docs/clients/other).

### Claude Code

One command:

```sh
claude mcp add --transport http --scope user justclaw-it https://justclaw.it.com/mcp \
  --header "Authorization: Bearer <YOUR_API_KEY>"
```

### Cursor

Add to `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "justclaw-it": {
      "url": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer <YOUR_API_KEY>" }
    }
  }
}
```

### Codex CLI

Add to `~/.codex/config.toml`:

```toml
[mcp_servers.justclaw-it]
url = "https://justclaw.it.com/mcp"
http_headers = { "Authorization" = "Bearer <YOUR_API_KEY>" }
```

### OpenClaw

Register the server, then reload a running gateway:

```sh
openclaw mcp set justclaw-it '{"url":"https://justclaw.it.com/mcp","transport":"streamable-http","headers":{"Authorization":"Bearer <YOUR_API_KEY>"}}'
openclaw mcp reload
```

### Hermes Agent

Add to `~/.hermes/config.yaml`, and put `JUSTCLAW_IT_API_KEY=<YOUR_API_KEY>` in `~/.hermes/.env`:

```yaml
mcp_servers:
  justclaw-it:
    url: "https://justclaw.it.com/mcp"
    headers:
      Authorization: "Bearer ${JUSTCLAW_IT_API_KEY}"
```

### Windsurf

Add to `~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "justclaw-it": {
      "serverUrl": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer <YOUR_API_KEY>" }
    }
  }
}
```

### Claude Desktop

Add to `claude_desktop_config.json` (macOS `~/Library/Application Support/Claude/`, Windows `%APPDATA%\Claude\`, Linux `~/.config/Claude/`). Claude Desktop reaches remote servers through the `mcp-remote` bridge, so it needs Node.js:

```json
{
  "mcpServers": {
    "justclaw-it": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://justclaw.it.com/mcp", "--header", "Authorization:${JUSTCLAW_IT_AUTH}"],
      "env": { "JUSTCLAW_IT_AUTH": "Bearer <YOUR_API_KEY>" }
    }
  }
}
```

### Any other MCP client

Streamable HTTP with a standard bearer header:

```json
{ "mcpServers": { "justclaw-it": { "url": "https://justclaw.it.com/mcp", "headers": { "Authorization": "Bearer <YOUR_API_KEY>" } } } }
```

### VS Code

Add to `.vscode/mcp.json` (or your user `mcp.json`); VS Code asks for the key once and stores it:

```json
{
  "inputs": [
    { "type": "promptString", "id": "justclaw-it-key",
      "description": "JustClaw-It API key", "password": true }
  ],
  "servers": {
    "justclaw-it": {
      "type": "http",
      "url": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer ${input:justclaw-it-key}" }
    }
  }
}
```


## Tools

The table is generated from the server's own `tools/list`, so it matches what your agent sees. Full parameters, examples and result fields: [Tool reference](/docs/tools).

| tool | parameters | credits | plan |
| --- | --- | --- | --- |
| [`search_components`](/docs/tools#search-components) | `query`, `limit` (optional), `category` (optional), `min_composite` (optional), `language` (optional), `license` (optional), `offset` (optional), `max_per_repo` (optional) | 0 | All plans |
| [`find_similar`](/docs/tools#find-similar) | `id`, `limit` (optional) | 0 | All plans |
| [`list_categories`](/docs/tools#list-categories) | `limit` (optional) | 0 | All plans |
| [`get_component`](/docs/tools#get-component) | `id` | 1 | All plans |
| [`library_stats`](/docs/tools#library-stats) | none | 0 | All plans |
| [`list_licenses`](/docs/tools#list-licenses) | none | 0 | All plans |
| [`get_component_bundle`](/docs/tools#get-component-bundle) | `component_id` | 3 | Pro |
| [`compose_starter`](/docs/tools#compose-starter) | `prompt`, `stack` (optional) | 10 | Pro |

Each result carries five sub-scores (completeness, code quality, deployability, reusability, strategic value) and a `composite` score from 0 to 10; filter with `min_composite`. See [Scores & ranking](/docs/scores).

## Credits & plans

Searching is free. One credit is one component pull (`get_component`). Free gets 30 credits on day one, then 10 a day that do not carry over. Paid plans refill weekly, keep what you don't spend, and earn up to 1.5x credits the longer you stay. Pro adds component bundles and starter projects. When credits run out, pulls stop until the next refill, renewal or an upgrade; you are never billed per credit. Live prices and checkout: [/pricing](/pricing). More: [Credits & plans](/docs/credits).

| plan | price | credits | fair-use cap | API keys | extras |
| --- | --- | --- | --- | --- | --- |
| Free | $0 | 10 per day, plus 30 on day one; resets daily, no carry-over | none | 1 | none |
| Solo | $10/month | 300 per week; unused credits carry over | 6,000 distinct components a year | 1 | none |
| Indie | $19/month | 1,000 per week; unused credits carry over | 15,000 distinct components a year | 1 | none |
| Pro | $49/month | 5,000 per week; unused credits carry over | 100,000 distinct components a year | 3 | component bundles, starter projects |

## Search limits

Search and the other discovery tools (`find_similar`, `library_stats`, `list_categories`, `list_licenses`, `search_components`) cost no credits but need an API key and are rate-limited so free search can't be abused. A call over a limit gets a readable error instead of results; nothing is charged.

| plan | searches per minute, per key | searches per day, per key |
| --- | --- | --- |
| Free | 20 | 300 |
| Solo | 30 | 2,000 |
| Indie | 30 | 4,000 |
| Pro | 60 | 10,000 |

Per network (client IP, IPv6 /64): 60 searches a minute across all keys, and 1,000 a day across new free accounts. Days reset at 00:00 UTC.

## Licences & attribution

- Every component is third-party open-source code, served under its **original licence**. JustClaw-It sells access to the search and retrieval service (credits), not the code.
- The public library only includes permissive and weak-copyleft licences. Strong copyleft (GPL, AGPL) and code without a clear licence are excluded.
- Each result carries its SPDX licence, copyright holder and repository, and returned source starts with an attribution header. **Keep that header**, and include the licence text where the licence requires it (a `THIRD_PARTY_LICENSES` or NOTICE file works).
- The full list of source repositories, licences and copyright holders: `list_licenses`, or [/licenses](/licenses).

More: [Licences & attribution](/docs/licences).

## FAQ

### How is this different from Context7?

Context7 tells your agent how a library works; JustClaw-It hands it production code that uses it. They complement each other: docs for the API, JustClaw-It for a working, attributed implementation. A longer comparison is on the [blog](/blog/justclaw-it-vs-context7).

### What does a search cost?

Nothing. A pull is 1 credit; `get_component_bundle` is 3 and `compose_starter` is 10. Connecting, listing tools and handshakes are free.

### What happens when I run out of credits?

Pulls stop until your next refill (tomorrow on Free, next week on paid plans) or until you upgrade. Search keeps working within its limits. More answers: [FAQ](/docs/faq) and [Troubleshooting](/docs/troubleshooting).

## All pages

- Start: [Quickstart](/docs/quickstart)
- Reference: [Tools](/docs/tools), [Credits & plans](/docs/credits), [Licences & attribution](/docs/licences), [Scores & ranking](/docs/scores), [Security advisories](/docs/security-advisories), [MCP App view](/docs/mcp-app)
- Tooling: [CLI](/docs/cli), [Agent skills](/docs/skills)
- Help: [FAQ](/docs/faq), [Troubleshooting](/docs/troubleshooting), [Changelog](/docs/changelog)
- For LLMs: [/llms.txt](/llms.txt) (index) and [/llms-full.txt](/llms-full.txt) (every page in one file). Every page is also available as Markdown: add `.md` to its URL.

---

URL: https://justclaw.it.com/docs/quickstart

# Quickstart

Two minutes from nothing to your agent searching 1,459,705 licence-cleared components.

## 1. Get a free API key

Sign up at [/signup](/signup) with your email (no card). Confirm the link we send and copy the key it shows you. It starts with `cobalt_live_` and is shown once; you can regenerate it at [/account](/account). The Free plan gives you free search plus 30 pull credits on day one, then 10 a day.

## 2. Connect your agent

The quickest way is the installer. It finds Claude Code, Claude Desktop, Cursor, Windsurf, Codex, OpenClaw and Hermes on your machine and configures each one (VS Code is manual, see below):

```sh
npx @justclaw-it/cli init
```

or, without npm on your PATH:

```sh
curl -fsSL https://justclaw.it.com/install | sh
```

> The `@justclaw-it/cli` 0.1.0 release is rolling out on npm. If `npx` stops with `justclaw-it: not found`, use the manual setup for your client below; it is one command or one config entry.

Or set it up by hand. Every client uses the same server URL, `https://justclaw.it.com/mcp` (Streamable HTTP), and the header `Authorization: Bearer <YOUR_API_KEY>`:

| client | how | guide |
| --- | --- | --- |
| Claude Code | `claude mcp add` one-liner | [Claude Code](/docs/clients/claude-code) |
| Claude Desktop | `claude_desktop_config.json` via `mcp-remote` | [Claude Desktop](/docs/clients/claude-desktop) |
| Cursor | `~/.cursor/mcp.json` | [Cursor](/docs/clients/cursor) |
| Windsurf | `mcp_config.json` with `serverUrl` | [Windsurf](/docs/clients/windsurf) |
| VS Code | `.vscode/mcp.json` with a prompted key | [VS Code](/docs/clients/vscode) |
| Codex CLI | `~/.codex/config.toml` | [Codex](/docs/clients/codex) |
| OpenClaw | `openclaw mcp set` | [OpenClaw](/docs/clients/openclaw) |
| Hermes Agent | `~/.hermes/config.yaml` | [Hermes Agent](/docs/clients/hermes) |
| anything else | standard bearer header | [Other clients](/docs/clients/other) |

## 3. Restart and try it

Restart the agent so it loads the new server, then ask in plain language:

- *"Search JustClaw-It for an express JWT auth middleware with a permissive licence."*
- *"Find a Python Stripe webhook signature check on JustClaw-It and pull the best one into this project."*

The agent calls `search_components` (free), picks a result by fit, score and licence, and calls `get_component` (1 credit) to pull the source. Keep the attribution header that comes with the code.

## 4. Check it works

```sh
npx @justclaw-it/cli doctor
```

`doctor` tests the connection, shows your plan and usage, and lists which agents are configured. Without the CLI:

```sh
curl -H "Authorization: Bearer $JUSTCLAW_IT_API_KEY" https://justclaw.it.com/usage
```

## Next

- [Tool reference](/docs/tools): every tool, parameter and result field.
- [Licences & attribution](/docs/licences): what you must keep when you reuse a component.
- [Agent skills](/docs/skills): teach your agent when to search before it writes.
- [Troubleshooting](/docs/troubleshooting) if something doesn't connect.

---

URL: https://justclaw.it.com/docs/clients/claude-code

# Claude Code

Add JustClaw-It to Claude Code with one command. The `--scope user` flag makes it available in every project.

## Automatic

```sh
npx @justclaw-it/cli init
```

The CLI detects Claude Code, adds the server, and installs the three [agent skills](/docs/skills) into `~/.claude/skills`.

## Manual

```sh
claude mcp add --transport http --scope user justclaw-it https://justclaw.it.com/mcp \
  --header "Authorization: Bearer <YOUR_API_KEY>"
```

Replace `<YOUR_API_KEY>` with your key. To add it to one project only, use `--scope project` instead; Claude Code then writes it to that project's `.mcp.json` (don't commit a file that holds your key).

## Check it

```sh
claude mcp list
```

`justclaw-it` should be listed as connected. Inside a session, `/mcp` shows the server and its tools. Claude Code prefixes MCP tool names with the server name, so the tools appear as `mcp__justclaw-it__search_components`, `mcp__justclaw-it__get_component` and so on.

## Try it

> Search JustClaw-It for a rate limiter middleware for express, permissive licence only, and pull the best-scored one.

## Remove it

```sh
claude mcp remove justclaw-it --scope user
```

or `npx @justclaw-it/cli uninstall`, which removes exactly what `init` added. Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/claude-desktop

# Claude Desktop

Claude Desktop reaches remote MCP servers that use an API key through the `mcp-remote` bridge, so you need Node.js 18 or newer on the machine.

## Automatic

```sh
npx @justclaw-it/cli init
```

The CLI detects Claude Desktop and writes the entry below for you, backing up the file first.

## Manual

Open `claude_desktop_config.json`:

| OS | folder |
| --- | --- |
| macOS | `~/Library/Application Support/Claude/` |
| Windows | `%APPDATA%\Claude\` |
| Linux | `~/.config/Claude/` |

Add the `justclaw-it` entry under `mcpServers` (merge it with any servers already there):

```json
{
  "mcpServers": {
    "justclaw-it": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://justclaw.it.com/mcp", "--header", "Authorization:${JUSTCLAW_IT_AUTH}"],
      "env": { "JUSTCLAW_IT_AUTH": "Bearer <YOUR_API_KEY>" }
    }
  }
}
```

Replace `<YOUR_API_KEY>` with your key. The key goes in `env` so that the header value `Bearer <key>` (which contains a space) reaches `mcp-remote` as one argument.

## Check it

Quit Claude Desktop completely and reopen it (closing the window is not enough on macOS). The JustClaw-It tools then show in the tools menu of a new chat. If they don't, Claude Desktop's MCP log for the `justclaw-it` server usually says why: most often Node.js is missing or the key is wrong.

> Claude's custom connectors (Settings, Connectors) sign in with OAuth rather than an API-key header, and JustClaw-It's OAuth sign-in is not open to the public yet. Use the bridge setup above.

## Try it

> Use JustClaw-It to find a React drag-and-drop file upload component and show me its licence before pulling it.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/cursor

# Cursor

## Automatic

```sh
npx @justclaw-it/cli init
```

## Manual

Add the server to `~/.cursor/mcp.json` (all projects), or to `.cursor/mcp.json` in one project:

```json
{
  "mcpServers": {
    "justclaw-it": {
      "url": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer <YOUR_API_KEY>" }
    }
  }
}
```

Replace `<YOUR_API_KEY>` with your key. If the file already has servers, add `justclaw-it` inside the existing `mcpServers` object. Keep a project-level file that holds your key out of version control.

## Check it

Open Cursor's MCP settings: `justclaw-it` should show as enabled with its tools listed. If it shows an error, check the URL ends in `/mcp` and the header is exactly `Bearer ` followed by the key.

## Try it

In Agent mode:

> Search JustClaw-It for a TypeScript retry with exponential backoff helper, min composite 6, and add the best one to src/lib.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/windsurf

# Windsurf

Windsurf's Cascade agent reads remote MCP servers from `mcp_config.json`. Remote servers use `serverUrl` (or `url`) rather than a command.

## Automatic

```sh
npx @justclaw-it/cli init
```

The CLI writes `~/.codeium/windsurf/mcp_config.json`.

## Manual

Add to `~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "justclaw-it": {
      "serverUrl": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer <YOUR_API_KEY>" }
    }
  }
}
```

Replace `<YOUR_API_KEY>` with your key.

> Windsurf's documentation now lives under the Devin Desktop name. For its legacy Cascade agent the file is `~/.config/devin/mcp_config.json` on macOS and Linux and `%APPDATA%\devin\mcp_config.json` on Windows; the same entry works there. Its newer Devin Local agent configures MCP servers in the Devin CLI config files instead; see Devin's MCP documentation. The config supports `${env:VAR_NAME}` in `headers`, so you can write `"Authorization": "Bearer ${env:JUSTCLAW_IT_API_KEY}"` instead of the literal key.

## Check it

Open the MCP section of the Cascade panel and refresh: `justclaw-it` should list its tools. Cascade can use at most 100 tools across all servers at once; JustClaw-It adds 8.

## Try it

> Search JustClaw-It for a Go JWT validation middleware with a permissive licence.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/vscode

# VS Code

VS Code (with GitHub Copilot agent mode) supports remote HTTP MCP servers in `mcp.json`. The installer does not configure VS Code yet, so set it up by hand.

## Manual

Create `.vscode/mcp.json` in your workspace, or run **MCP: Open User Configuration** from the Command Palette to add it for every workspace:

```json
{
  "inputs": [
    { "type": "promptString", "id": "justclaw-it-key",
      "description": "JustClaw-It API key", "password": true }
  ],
  "servers": {
    "justclaw-it": {
      "type": "http",
      "url": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer ${input:justclaw-it-key}" }
    }
  }
}
```

The `inputs` entry makes VS Code ask for your key the first time the server starts and store it securely, so the key is never written to the file. That makes the workspace file safe to commit.

You can also run **MCP: Add Server** from the Command Palette, choose **HTTP**, and enter `https://justclaw.it.com/mcp`; then add the `headers` entry above to the server it creates.

## Check it

Open the Chat view in agent mode and select the tools button: the `justclaw-it` tools should be listed. If the server shows an error, use **MCP: List Servers**, select `justclaw-it`, and show its output.

> VS Code doesn't forward servers that need interactive inputs (like `${input:...}`) to its separate Copilot agent host. If you use that harness, follow VS Code's guide to replacing input prompts with environment variables.

## Try it

> Use JustClaw-It to search for a Python FastAPI JWT dependency, permissive licence.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/codex

# Codex

The Codex CLI reads MCP servers from `~/.codex/config.toml` and supports Streamable HTTP servers with custom headers.

## Automatic

```sh
npx @justclaw-it/cli init
```

## Manual

Add to `~/.codex/config.toml`:

```toml
[mcp_servers.justclaw-it]
url = "https://justclaw.it.com/mcp"
http_headers = { "Authorization" = "Bearer <YOUR_API_KEY>" }
```

Replace `<YOUR_API_KEY>` with your key.

## Check it

Start Codex and run `/mcp`: `justclaw-it` should be listed with its tools.

## Try it

> Use JustClaw-It to find a Rust CLI argument parsing example with a permissive licence and adapt it to this crate.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/openclaw

# OpenClaw

## Automatic

```sh
npx @justclaw-it/cli init
```

The CLI registers the server and installs the [agent skills](/docs/skills) into `~/.openclaw/skills`.

## Manual

Register the server, then reload a running gateway:

```sh
openclaw mcp set justclaw-it '{"url":"https://justclaw.it.com/mcp","transport":"streamable-http","headers":{"Authorization":"Bearer <YOUR_API_KEY>"}}'
openclaw mcp reload
```

Replace `<YOUR_API_KEY>` with your key.

## Check it

Ask your agent to call `library_stats` on JustClaw-It (free). It returns the live component count.

## Try it

> Search JustClaw-It for a Stripe checkout session handler in TypeScript and pull the best match with its attribution.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/hermes

# Hermes Agent

## Automatic

```sh
npx @justclaw-it/cli init
```

## Manual

Add to `~/.hermes/config.yaml`:

```yaml
mcp_servers:
  justclaw-it:
    url: "https://justclaw.it.com/mcp"
    headers:
      Authorization: "Bearer ${JUSTCLAW_IT_API_KEY}"
```

and put your key in `~/.hermes/.env`:

```sh
JUSTCLAW_IT_API_KEY=<YOUR_API_KEY>
```

## Check it

Restart Hermes and ask it to call `library_stats` on JustClaw-It (free).

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/clients/other

# Other MCP clients

JustClaw-It is a standard remote MCP server. Any client that speaks Streamable HTTP and can send a custom header works.

| setting | value |
| --- | --- |
| URL | `https://justclaw.it.com/mcp` |
| transport | Streamable HTTP |
| header | `Authorization: Bearer <YOUR_API_KEY>` |

The common JSON shape:

```json
{ "mcpServers": { "justclaw-it": { "url": "https://justclaw.it.com/mcp", "headers": { "Authorization": "Bearer <YOUR_API_KEY>" } } } }
```

Some clients call the URL field `serverUrl` or `httpUrl`, and some put headers under `requestInit`. If your client only supports stdio servers, bridge it with `mcp-remote` the same way as [Claude Desktop](/docs/clients/claude-desktop).

## Check it with curl

```sh
curl -s https://justclaw.it.com/mcp \
  -H "Authorization: Bearer $JUSTCLAW_IT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'
```

A `200` with the server's capabilities means the key and URL are right. A `401` means the key is missing, wrong or revoked. Connecting, `initialize` and `tools/list` never cost credits.

Problems: [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/tools

# Tool reference

JustClaw-It exposes 8 MCP tools. Parameter tables on this page come from the server's own `tools/list`, so they always match what your agent sees. Your client may prefix the names (Claude Code shows `mcp__justclaw-it__search_components`).

| tool | credits per call | plan |
| --- | --- | --- |
| `search_components` | 0 | All plans |
| `find_similar` | 0 | All plans |
| `list_categories` | 0 | All plans |
| `get_component` | 1 | All plans |
| `library_stats` | 0 | All plans |
| `list_licenses` | 0 | All plans |
| `get_component_bundle` | 3 | Pro |
| `compose_starter` | 10 | Pro |

Connecting, `initialize`, `tools/list` and reading the [MCP App view](/docs/mcp-app) resource never cost credits. Discovery tools are free but rate-limited ([limits](/docs/credits#search-limits)). A call refused before it runs (bad key, no credits, rate limit) is not charged; a pull refused by the fair-use cap and a Pro tool tried on a non-Pro key are refunded.

A typical agent loop is: `search_components` with a concrete query and a `license` filter, read the results, then `get_component` on the one that fits best.

## search_components

**Credits:** 0 per call. **Plan:** All plans.

Semantic search over the public library. Your query is embedded and matched against component descriptions; results are ranked by similarity blended with the quality score (see [Scores & ranking](/docs/scores)). Results carry metadata, scores, licence and a GitHub permalink, but no source code: pull the one you want with `get_component`.

### Parameters

| parameter | type | required | default |
| --- | --- | --- | --- |
| `query` | string | yes |  |
| `limit` | integer | no | `8` |
| `category` | string | no |  |
| `min_composite` | number | no | `0.0` |
| `language` | string | no |  |
| `license` | string | no | `"any"` |
| `offset` | integer | no | `0` |
| `max_per_repo` | integer | no | `3` |

- `query`: a short, concrete description of the job and the stack, for example `"express jwt auth middleware"`.
- `limit`: results per page (default 8, at most 50).
- `category`: one function tag, from `list_categories`. Common ones: `ai`, `ui`, `auth`, `database`, `payments`, `pos`, `crm`, `voice`, `email`, `infra`, `integration`, `automation`, `analytics`, `files`, `realtime`, `scraping`, `dev-tools`, `testing`, `security`, `search`, `chat`, `cli`.
- `min_composite`: drop results whose composite score is below this (0 to 10).
- `language`: one of `c`, `cpp`, `csharp`, `dart`, `go`, `java`, `javascript`, `kotlin`, `php`, `python`, `ruby`, `rust`, `shell`, `sql`, `svelte`, `swift`, `typescript`, `vue`.
- `license`: `permissive` (MIT, BSD, Apache-2.0, ISC and similar), `commercial-safe` (permissive plus weak copyleft such as MPL-2.0), `open-source`, or `any` (the default). The public library never serves strong copyleft, so `open-source` and `any` both return permissive and weak-copyleft code. Use `permissive` when the code goes into a closed product.
- `offset`: paging. Pages stop after offset 450.
- `max_per_repo`: at most this many results from one source repository (0 = no cap).

Language, licence and minimum-score filters are applied inside the database query, so a filtered search still returns full pages.

### Example call

```json
{
  "name": "search_components",
  "arguments": {
    "query": "python stripe webhook signature verify",
    "limit": 5,
    "license": "permissive",
    "min_composite": 6
  }
}
```

### What it returns

`{"results": [...]}`. Each result has `id`, `name`, `description`, `repo`, `path`, `loc`, `language`, `tags`, `source_url` (GitHub permalink), `similarity`, `scores` (`completeness`, `code_quality`, `deployability`, `reusability`, `strategic_value`, `composite`), `license` (SPDX), `license_kind` (`permissive` or `weak-copyleft`) and `attribution` (`repo_url`, `license_spdx`, `resell_class`, `copyright_holder`, `copyleft_flag`, `text`). Some results also carry [`security_advisories`](/docs/security-advisories). A `null` composite means the component has not been scored yet, not that it scored badly.

## get_component

**Credits:** 1 per call. **Plan:** All plans.

Pulls one component: its full source, GitHub permalink, licence, dependencies and an attribution block. The returned source starts with an attribution header comment; keep it with the code. This is the call that spends a credit.

### Parameters

| parameter | type | required | default |
| --- | --- | --- | --- |
| `id` | string | yes |  |

- `id`: the `id` from a search result.

Every call costs 1 credit, including a re-pull of a component you already fetched (a re-pull does not count twice against your plan's yearly fair-use cap) and a call with an id that is not in the public library, so use ids from search results. A pull refused by the fair-use cap is refunded.

### Example call

```json
{
  "name": "get_component",
  "arguments": { "id": "<id from search_components>" }
}
```

### What it returns

`id`, `name`, `description`, `repo`, `repo_url`, `source_url`, `language`, `function_tags`, `tech_stack` (includes the file path), `dependencies`, `license`, `license_kind`, `attribution` and `source_code` (starting with the attribution header), plus `security_advisories` when present. Scores are on the search result, not here. For weak-copyleft files the header also says that modifications to that file stay under its licence. Errors: `not available` (unknown or not in the public library), `pull_ceiling_exceeded` (yearly fair-use cap; more credits do not lift it).

## find_similar

**Credits:** 0 per call. **Plan:** All plans.

Components similar to a given component id. **On the public library this currently returns an empty list**: nearest-neighbour lookup is not yet available behind the licence gate. It costs nothing; use `search_components` with a description of the component instead.

### Parameters

| parameter | type | required | default |
| --- | --- | --- | --- |
| `id` | string | yes |  |
| `limit` | integer | no | `8` |

### Example call

```json
{
  "name": "find_similar",
  "arguments": { "id": "<component id>", "limit": 8 }
}
```

### What it returns

`{"results": []}` today; the same shape as `search_components` once enabled.

## list_categories

**Credits:** 0 per call. **Plan:** All plans.

The most-used function tags with their counts. These are the valid values for `search_components.category`.

### Parameters

| parameter | type | required | default |
| --- | --- | --- | --- |
| `limit` | integer | no | `40` |

### Example call

```json
{
  "name": "list_categories",
  "arguments": { "limit": 40 }
}
```

### What it returns

`{"categories": [{"tag": "auth", "count": ...}, ...]}`, most used first.

## library_stats

**Credits:** 0 per call. **Plan:** All plans.

Live library counts (refreshed in the background about every 15 minutes).

### Parameters

No parameters.

### Example call

```json
{
  "name": "library_stats",
  "arguments": {}
}
```

### What it returns

`total_components`, `callable_components`, `categorised` and the licence mode. While the counts are being computed after a restart it returns `{"status": "warming up"}`; retry in a minute.

## list_licenses

**Credits:** 0 per call. **Plan:** All plans.

Every source repository in the library with its SPDX licence and copyright holder: a NOTICE file you can keep with a project. The same list is at [/licenses](/licenses).

### Parameters

No parameters.

### Example call

```json
{
  "name": "list_licenses",
  "arguments": {}
}
```

### What it returns

`{"licenses": [{"repo_url", "license_spdx", "copyright_holder", "components"}, ...]}`.

## get_component_bundle

**Credits:** 3 per call. **Plan:** Pro.

Pro only. One component plus the components it imports from its own repository, each with source and an attribution header, and a manifest of files, npm/pip packages and install commands. Use it when one file is not enough to run.

### Parameters

| parameter | type | required | default |
| --- | --- | --- | --- |
| `component_id` | string | yes |  |

- `component_id`: the `id` from a search result.

On a non-Pro key the call is refused with `pro_required` and the credit is refunded, so trying it costs nothing. If no bundle can be built the credits are refunded.

### Example call

```json
{
  "name": "get_component_bundle",
  "arguments": { "component_id": "<id>" }
}
```

### What it returns

The components with source and headers, a manifest, and `credits_charged`.

## compose_starter

**Credits:** 10 per call. **Plan:** Pro.

Pro only. Describe what you are building and get a starter project assembled from 3 to 8 complementary library components: file tree, files with attribution headers, a README listing every source and licence, a NOTICE file and install commands. Expect to fix some glue: the components come from different repositories.

### Parameters

| parameter | type | required | default |
| --- | --- | --- | --- |
| `prompt` | string | yes |  |
| `stack` | string | no |  |

- `prompt`: one paragraph on what you are building and the features it needs.
- `stack`: optional, for example `"nextjs"` or `"python fastapi"`.

Refused calls (non-Pro key, not enough credits, nothing matched) are refunded.

### Example call

```json
{
  "name": "compose_starter",
  "arguments": {
    "prompt": "SaaS dashboard with email login, Stripe subscriptions and transactional email",
    "stack": "nextjs"
  }
}
```

### What it returns

The starter (tree, files, README, NOTICE, install commands) and `credits_charged`.


## Errors

Tool errors come back as JSON text, for example `{"error": "pull_ceiling_exceeded", "message": "..."}`. Refusals before the tool runs (bad key, no credits, rate limits) come back as an MCP error with a readable message. The full list is in [Troubleshooting](/docs/troubleshooting).

---

URL: https://justclaw.it.com/docs/credits

# Credits & plans

JustClaw-It charges for pulling code, not for looking. Search is free on every plan; credits pay for pulls.

## What costs credits

| tool | credits per call | plan |
| --- | --- | --- |
| `search_components` | 0 | All plans |
| `find_similar` | 0 | All plans |
| `list_categories` | 0 | All plans |
| `get_component` | 1 | All plans |
| `library_stats` | 0 | All plans |
| `list_licenses` | 0 | All plans |
| `get_component_bundle` | 3 | Pro |
| `compose_starter` | 10 | Pro |

Free (0 credits): connecting, `initialize`, `tools/list`, reading the MCP App view, and every discovery tool (`find_similar`, `library_stats`, `list_categories`, `list_licenses`, `search_components`). One credit is one `get_component` pull. Calls refused before they run (bad key, no credits, rate limit) are not charged. A Pro tool tried on a non-Pro key, a Pro tool that produces nothing, and a pull refused by the fair-use cap are refunded. A pull of an id that isn't in the public library still uses its credit and counts toward the fair-use cap.

## Plans

| plan | price | credits | fair-use cap | API keys | extras |
| --- | --- | --- | --- | --- | --- |
| Free | $0 | 10 per day, plus 30 on day one; resets daily, no carry-over | none | 1 | none |
| Solo | $10/month | 300 per week; unused credits carry over | 6,000 distinct components a year | 1 | none |
| Indie | $19/month | 1,000 per week; unused credits carry over | 15,000 distinct components a year | 1 | none |
| Pro | $49/month | 5,000 per week; unused credits carry over | 100,000 distinct components a year | 3 | component bundles, starter projects |

- **Free:** 30 credits on day one (they don't expire), then 10 a day. The daily credits refill every 24 hours and don't carry over. No card.
- **Solo** ($10/month), **Indie** ($19/month) and **Pro** ($49/month) refill every 7 days (300, 1,000 and 5,000 credits) and keep what you don't spend while you stay subscribed.
- **Pro** adds `get_component_bundle` (3 credits) and `compose_starter` (10 credits), and up to 3 API keys on one account.

Live prices and checkout: [/pricing](/pricing). Payments are handled by Stripe. Prices are in US dollars and exclude sales tax; where tax applies (currently Texas), Stripe adds it at checkout and shows it before you pay.

## No overage, ever

Every plan is a hard cap. When your credits run out, pulls stop until the next refill or renewal, or until you upgrade. JustClaw-It never bills per credit and never charges more than your plan's price (plus any sales tax shown at checkout). Search keeps working within its limits while you are out of credits.

## Fair-use cap

Paid plans have a yearly cap on **distinct** components pulled (6,000 on Solo, 15,000 on Indie, 100,000 on Pro), to stop bulk copying of the library. Re-pulling something you already pulled doesn't count again. The cap is separate from credits: more credits don't lift it. Hitting it returns `pull_ceiling_exceeded`.

## Loyalty

Paid plans earn more credits the longer you stay subscribed, up to 1.5x the weekly refill.

| months subscribed | weekly credit multiplier |
| --- | --- |
| 0+ | 1.00x |
| 3+ | 1.10x |
| 6+ | 1.20x |
| 12+ | 1.35x |
| 24+ | 1.50x |

## Search limits

Discovery tools cost no credits but need an API key and are rate-limited per key and per network, so free search can't be abused. Over a limit you get a readable error (`search_rate_limited` or `search_daily_cap`) and nothing is charged.

| plan | searches per minute, per key | searches per day, per key |
| --- | --- | --- |
| Free | 20 | 300 |
| Solo | 30 | 2,000 |
| Indie | 30 | 4,000 |
| Pro | 60 | 10,000 |

Per network (client IP, IPv6 /64): 60 searches a minute across all keys, and 1,000 a day across new free accounts. Days reset at 00:00 UTC. A search page holds up to 50 results.

## Usage and keys

- See balance and recent calls at [/account](/account), or run `npx @justclaw-it/cli doctor`.
- With a key: `curl -H "Authorization: Bearer $JUSTCLAW_IT_API_KEY" https://justclaw.it.com/usage`.
- Regenerate a leaked key at [/account](/account). One free account per person.

## Cancelling and refunds

Cancel any time yourself with **Manage billing / Cancel** on your [account page](/account#billing) (the same screen updates your card and lists invoices), or by email. You keep your plan until the end of the period you paid for. Used credits are not refundable. A first purchase can be refunded within 7 days if no credits were used. Full rules: [refund policy](/refund).

---

URL: https://justclaw.it.com/docs/licences

# Licences & attribution

Every component in JustClaw-It is open-source code written by someone else. You can reuse it under its **original licence**, and that licence usually asks for one thing above all: keep the copyright and licence notice. JustClaw-It's job is to make that easy by putting the licence and attribution on every result.

## What the public library serves

- **Permissive** licences (for example MIT, BSD, Apache-2.0, ISC) and **weak copyleft** (for example MPL-2.0).
- **Excluded:** strong copyleft (GPL, AGPL), code with no clear licence, and repositories whose licence has not been checked. A repository with no licence record is left out, not let in.
- Licence data is refreshed from the source repositories every month.

## What every result tells you

| field | meaning |
| --- | --- |
| `license` | SPDX identifier, for example `MIT` |
| `license_kind` | `permissive` or `weak-copyleft` |
| `attribution.repo_url` | the source repository |
| `attribution.copyright_holder` | who holds the copyright, when it could be read |
| `attribution.copyleft_flag` | true for copyleft licences |
| `attribution.text` | a ready-made attribution line |
| `source_url` | GitHub permalink to the file |

## The attribution header

Source returned by `get_component` starts with a comment block. Its first line is the component's attribution text (source repository and licence, plus the copyright holder where known), and the comment style follows the file type. Roughly:

```text
// Source: https://github.com/<owner>/<repo> | License: MIT
// Provided via justclaw.it.com; keep this notice with the code.
```

For weak-copyleft files there is one more line: modifications to that file must stay under its licence.

## What you need to do

1. **Keep the header** in every file that contains pulled code, even after you adapt it.
2. **Ship the licence text where the licence requires it.** MIT and BSD require the copyright and permission notice in copies of the software; Apache-2.0 also asks you to keep any NOTICE file and mark changed files. A `THIRD_PARTY_LICENSES` (or NOTICE) file that lists each component, its repository, licence and copyright holder covers this. `list_licenses` and [/licenses](/licenses) give you that list for the whole library.
3. **For weak-copyleft files** (MPL-2.0 and similar), keep modifications to that file under the same licence and keep it as a separate file.
4. **Filter up front** when the code goes into a closed product: `license: "permissive"` on `search_components` returns permissive code only.

The [`justclaw-it-pull` skill](/docs/skills) does steps 1 and 2 for your agent.

## Limits of the data

Licence data is collected automatically from each repository's licence files and metadata. We work to keep it right but can't guarantee it, and a repository's licence can change. You are responsible for licence compliance in what you ship (see the [terms](/terms)); check the licence of anything important.

## Takedowns

If you own code in the library and want it removed, or think it is listed under the wrong licence, email mike+mcpsupport@two7.design with the repository URL. We review and act promptly.

---

URL: https://justclaw.it.com/docs/scores

# Scores & ranking

Every result carries five sub-scores and a composite, all from 0 to 10, plus a `similarity` to your query.

## The five sub-scores

| score | weight in composite | asks |
| --- | --- | --- |
| `completeness` | 25% | Is it a whole, working unit or a fragment? |
| `code_quality` | 20% | Is it readable, typed, handles errors? |
| `deployability` | 20% | Could it run in production with little change? |
| `reusability` | 25% | Can it be lifted into another project cleanly? |
| `strategic_value` | 10% | Is it something many projects need? |

`composite` is the weighted sum. Filter on it with `min_composite`.

## Where scores come from

Scores come from an automated grading pipeline. Components first get a heuristic baseline score, and a growing share is re-graded by language-model graders against the same rubric. Scores are a guide for choosing between results, not a review or a guarantee: read the code before you rely on it. A `null` composite means "not scored yet", not "scored badly".

## How results are ranked

1. **Retrieval.** Your query is embedded and matched against component descriptions (semantic search). Language, licence and `min_composite` filters are applied inside the database query, so filtered searches still return full pages.
2. **Re-ranking.** The candidates are re-ordered by a blend of similarity (80%) and composite score (20%). Unscored components count as a 5 here.
3. **Clean-up.** Locale files, tests and vendored copies are pushed down; forks and copies of the same file are collapsed to the best-ranked one; and by default at most 3 results come from one repository (`max_per_repo`).

## The reputation tiebreaker

A small set of widely used repositories also has an external reputation signal: how often the repository is recommended and mentioned on the web. In ranking only, their composite is nudged by 5%: `0.95 × composite + 0.05 × signal`. The signal is positive-only, so it can lift a well-known repository's component slightly above an otherwise equal one, but it never pushes anything down. The composite you see in results is the real, unmodified score. Repositories without reputation data rank exactly as they would otherwise.

Security advisories are deliberately **not** part of this signal; they are returned as a separate warning. See [Security advisories](/docs/security-advisories).

---

URL: https://justclaw.it.com/docs/security-advisories

# Security advisories

Some search results and pulls carry a `security_advisories` field. It lists published CVE and GHSA identifiers that name the component's **repository**.

```json
"security_advisories": {
  "ids": ["CVE-2025-XXXXX", "GHSA-xxxx-xxxx-xxxx"],
  "scope": "repository",
  "note": "Published advisories naming this repository; check whether they affect this file and version. Not used in ranking."
}
```

## What it means

- An advisory exists that names the repository. It may affect a different file, an older version, or a feature you don't use.
- Check the advisory against the file and version you are pulling before you ship it. Searching the identifier on the GitHub Advisory Database or NVD shows the affected versions.

## What it does not mean

- **It is not part of the score or the ranking.** A repository with advisories is not demoted; we show the warning instead, so you can decide.
- **No warning is not a clean bill of health.** The field is filled only for repositories we have reputation data for, which today is a small set of widely used projects. Most results have no `security_advisories` field because we have no data for them, not because they are known to be safe.
- It is not a vulnerability scan of the file itself.

For dependency-level checks after you pull code, keep using your usual tools (`npm audit`, `pip-audit`, Dependabot or similar).

---

URL: https://justclaw.it.com/docs/mcp-app

# MCP App view

MCP hosts that support **MCP Apps** (the MCP UI extension) can show JustClaw-It results as an interactive view instead of raw JSON. Hosts that don't support it get exactly the same JSON text, so nothing changes for them.

## What it shows

- **Search results** (`search_components`, `find_similar`): a card per component with repository, path, language, licence, lines of code, scores, similarity, tags, the attribution line and the GitHub permalink, plus a filter box that narrows the list by name, repo, language or tag.
- **One component** (`get_component`): the same card with dependencies and the component id, the source code, and a **Copy source** button.
- Errors from the tool (for example running out of credits) as a readable message.

## How it works

- The tools declare the view in their metadata (`_meta.ui.resourceUri` = `ui://justclaw-it/components.html`). The view is a resource with MIME type `text/html;profile=mcp-app`.
- The host renders it in a sandboxed frame. It only displays what the tool already returned: **it never calls tools itself**, so it can never spend a credit.
- Reading the view resource is free.
- The view loads the MCP Apps helper library from `unpkg.com`, the only external domain its content-security metadata declares.

The view picks up the host's light or dark theme and style variables when the host provides them.

---

URL: https://justclaw.it.com/docs/cli

# CLI

`@justclaw-it/cli` connects the coding agents on your machine to JustClaw-It in one command. It installs a `justclaw-it` command, needs Node.js 18.17 or newer, and has no runtime dependencies. It is MIT-licensed; the npm package contains its full source.

> The 0.1.0 release is rolling out on npm. If `npx` stops with `justclaw-it: not found`, set your agent up by hand from the [client guides](/docs/quickstart#2-connect-your-agent); it is one command or one config entry.

## init

```sh
npx @justclaw-it/cli init
```

or, without npm on your PATH (the script only runs the same CLI):

```sh
curl -fsSL https://justclaw.it.com/install | sh
```

1. Paste your API key, or press Enter to open [/signup](/signup) (free, no card).
2. The CLI checks the key with a live `tools/list` call.
3. It finds the agents on your machine and adds the `justclaw-it` MCP server to each. Every file it edits is backed up first as `<file>.justclaw-it-bak-<timestamp>`.
4. It installs the three [agent skills](/docs/skills) into Claude Code, OpenClaw and Hermes.

Supported clients and their ids: `claude-code`, `claude-desktop`, `cursor`, `windsurf`, `codex`, `openclaw`, `hermes`. VS Code is set up by hand ([guide](/docs/clients/vscode)).

## doctor

```sh
npx @justclaw-it/cli doctor
npx @justclaw-it/cli doctor --search "jwt auth middleware express"
```

Tests the connection, shows your plan and usage, and checks each agent's config. `--search` runs one real search (free).

## uninstall

```sh
npx @justclaw-it/cli uninstall
```

Removes the `justclaw-it` entries and the skills that `init` added, and nothing else.

## Options

| option | what it does |
| --- | --- |
| `--key <key>` | API key. Default: `$JUSTCLAW_IT_API_KEY`, then the saved key, then a prompt. |
| `--clients <list>` | Only these clients, comma-separated, for example `--clients claude-code,cursor`. |
| `--yes`, `-y` | Don't ask; configure every detected client. |
| `--no-skills` | Don't install the agent skills. |
| `--search "<query>"` | With `doctor`: run one real search. |
| `--url <url>` | MCP endpoint (default `https://justclaw.it.com/mcp`). |

Non-interactive, for scripts and CI:

```sh
JUSTCLAW_IT_API_KEY=<YOUR_API_KEY> npx @justclaw-it/cli init --yes --clients claude-code
```

## Where your key goes

The CLI writes the key only into each agent's own config file (as the `justclaw-it` MCP entry), or the agent's env file for Hermes, plus `~/.config/justclaw-it/config.json` (mode 600) so `doctor` can use it. It sends the key nowhere except https://justclaw.it.com and never prints it in full. Lost or leaked key: regenerate it at [/account](/account) and run `init` again.

## Upgrading from a pre-release

`init` cleans up after pre-release installs: old MCP entries and skill folders from earlier names are removed and replaced by `justclaw-it` and `justclaw-it-*`, and a key saved by a pre-release is moved to `~/.config/justclaw-it/`.

---

URL: https://justclaw.it.com/docs/skills

# Agent skills

The CLI installs three [Agent Skills](https://agentskills.io) that teach your agent when and how to use JustClaw-It. They go into Claude Code (`~/.claude/skills`), OpenClaw (`~/.openclaw/skills`) and Hermes (`~/.hermes/skills`). Skip them with `--no-skills`.

## justclaw-it-search

Search before writing anything a thousand projects already have: auth middleware, OAuth flows, payment webhooks, rate limiters, uploads, email senders, retry logic, data tables, API clients, CLI scaffolds. It tells the agent to:

1. call `search_components` with a short query naming the job and the stack;
2. pick by **fit** first (same language and framework, similar scope), then **quality** (`scores.composite`; null means unscored), then **licence**: permissive is fine, copyleft only if the project's licence is compatible, never code without a licence;
3. pull the chosen one with `get_component` and adapt it to the codebase;
4. not repeat the same search in one task.

## justclaw-it-pull

Pull a component (or a Pro bundle) into the project properly:

1. fetch with `get_component`, or `get_component_bundle` on Pro;
2. **check the licence before writing anything** (`license_spdx`, `resell_class`, `copyleft_flag`);
3. place it like local code: the project's naming, module system, formatter and types; delete what isn't used;
4. **attribute it**: keep the header in every file and record the component in `THIRD_PARTY_LICENSES`;
5. wire in the dependencies it needs.

## justclaw-it-starter (Pro)

Compose a new project with `compose_starter`: pin down the stack and features, compose, review the chosen components and their licences with you, write the project with every attribution header, README credits and NOTICE file, then install, build and fix the glue until it runs. Without Pro it falls back to search plus pull for each piece.

## Install them by hand

The skill folders (`justclaw-it-search`, `justclaw-it-pull`, `justclaw-it-starter`) ship inside the `@justclaw-it/cli` npm package, under `skills/`. Copy them into your agent's skills directory. Any agent that reads Agent Skills can use them, as long as the `justclaw-it` MCP server is configured.

---

URL: https://justclaw.it.com/docs/faq

# FAQ

## Is JustClaw-It a library I install?

No. It is a hosted MCP server. The CLI only writes a config entry (and optional agent skills) into your agents; searches run on our side and return code, scores and licences.

## What does it cost?

Search is free on every plan. Each pull (`get_component`) is 1 credit. Free: 30 credits on day one, then 10 a day. Solo $10, Indie $19 and Pro $49 a month refill weekly. Every plan is a hard cap; there is no overage billing. Prices exclude sales tax where it applies. [Credits & plans](/docs/credits).

## How do I cancel?

Sign in to your [account page](/account#billing) and press **Manage billing / Cancel**. You keep your plan until the end of the period you paid for. [Refund policy](/refund).

## Do I need an API key to search?

Yes. Search costs no credits, but every call needs a key so we can rate-limit it fairly. A free key takes a minute at [/signup](/signup).

## Can I use the code in a commercial product?

Usually yes, under the component's own licence. The public library only serves permissive (MIT, BSD, Apache-2.0, ISC and similar) and weak-copyleft (MPL-2.0 and similar) code. Keep the attribution header and ship the licence notices; for weak-copyleft files, keep your changes to those files under the same licence. Use `license: "permissive"` to avoid weak copyleft altogether. [Licences & attribution](/docs/licences).

## Is the code reviewed or tested?

Not by people, and not by running it. Components are graded automatically ([Scores & ranking](/docs/scores)) and filtered by licence. Treat a pulled component like any code from the internet: read it, test it, and check its dependencies.

## Which languages are covered?

The `language` filter accepts `c`, `cpp`, `csharp`, `dart`, `go`, `java`, `javascript`, `kotlin`, `php`, `python`, `ruby`, `rust`, `shell`, `sql`, `svelte`, `swift`, `typescript`, `vue`. Coverage varies by language, so if a filtered search comes back thin, try without `language` and check the `language` field of the results.

## Where does the code come from?

Public open-source repositories on GitHub with a licence we could identify. The full list of repositories, licences and copyright holders is at [/licenses](/licenses).

## How fresh is it?

New repositories are ingested continuously; the [status page](/status) shows when the last ingest ran. Licence data is re-checked monthly.

## Is the ranking sponsored?

No. Nobody pays for placement. Ranking is similarity plus the quality score, with a small positive-only reputation tiebreaker for well-known repositories ([Scores & ranking](/docs/scores)).

## How is this different from Context7, 21st.dev or GitHub search?

Context7 serves library documentation; JustClaw-It serves whole components of real code with their licence. 21st.dev is a curated React and Tailwind UI catalogue; JustClaw-It covers backend and full-stack code in many languages. GitHub code search finds text matches but leaves licence, quality and whole-component extraction to you. The blog has fair, detailed comparisons: [vs 21st.dev](/blog/justclaw-it-vs-21st-dev), [vs Context7](/blog/justclaw-it-vs-context7), [vs GitHub MCP](/blog/justclaw-it-vs-github-mcp-code-search), [vs Smithery and MCP directories](/blog/justclaw-it-vs-smithery-mcp-directories).

## What do you log?

Tool calls per key (time, tool, credits, number of results, and the query or id you sent, cut to 200 characters). Search text is kept for 90 days. We do not sell data or show ads. [Privacy policy](/privacy).

## Can teams share an account?

Pro accounts can hold up to 3 API keys, one per person or machine. Keys can't be shared outside your account ([terms](/terms)).

## Can I sign in with OAuth instead of a key?

Not yet for the public: OAuth sign-in exists but is invite-only. Use an API key.

## Who runs JustClaw-It?

JustClaw-It is a DBA of Two7 Design LLC. Contact: mike+mcpsupport@two7.design.

## Is the service up?

See [/status](/status), or [/status.json](/status.json) for machines.

---

URL: https://justclaw.it.com/docs/troubleshooting

# Troubleshooting

## The agent doesn't see any JustClaw-It tools

1. Restart the agent completely after changing its config (on macOS, quit Claude Desktop; closing the window is not enough).
2. Check the URL is exactly `https://justclaw.it.com/mcp`, including `/mcp`.
3. Check the header is `Authorization: Bearer <key>`, with one space after `Bearer` and no quotes inside the key.
4. Run `npx @justclaw-it/cli doctor`: it tests the key and every configured agent.
5. Try the curl check in [Other clients](/docs/clients/other#check-it-with-curl).

## 401 / invalid_token

The key is missing, mistyped or revoked. Copy it again from the signup email, or regenerate it at [/account](/account) and update your agent. A key is shown in full only once.

## "Out of credits"

You've used this period's credits; the message says when they refill. Pulls resume at the next refill (every 24 hours on Free, every 7 days on paid plans), or straight away if you upgrade at [/pricing](/pricing). Search keeps working. Nothing is billed beyond your plan's price (plus any sales tax shown at checkout).

## search_rate_limited / search_daily_cap

Search is free but limited per key and per network. `search_rate_limited`: wait a minute. `search_daily_cap`: the daily cap resets at 00:00 UTC; higher plans have higher caps ([limits](/docs/credits#search-limits)). Agents that loop on search burn through this fast; the [search skill](/docs/skills) tells them not to repeat a search within one task.

## "Daily free quota for your network reached"

Free accounts behind one network share a daily cap. Try again tomorrow or upgrade.

## pull_ceiling_exceeded

You've reached your plan's yearly cap on distinct components pulled. More credits don't lift it; re-pulling components you already have still works. Email mike+mcpsupport@two7.design if you have a real need for more.

## pro_required

`get_component_bundle` and `compose_starter` are Pro tools. The credit for the attempt is refunded. Pull the pieces one at a time with `get_component` instead, or upgrade.

## "not available"

The id isn't in the public library: it may have been removed, its licence may have changed, or it was mistyped. Use ids from a fresh `search_components` call. The pull still uses its credit (and counts once toward the yearly fair-use cap), so copy ids exactly.

## A filtered search returns few or no results

Loosen one filter at a time: drop `min_composite`, switch `license` from `permissive` to `commercial-safe`, or remove `category`. Describe the job, not the file name: `"verify stripe webhook signature in python"` works better than `"webhook.py"`.

## find_similar returns an empty list

That's expected for now on the public library; see [find_similar](/docs/tools#find-similar). Search with a description of the component instead.

## `npx @justclaw-it/cli` fails with "justclaw-it: not found"

The 0.1.0 release is rolling out on npm. Set up your client by hand from the [client guides](/docs/quickstart#2-connect-your-agent) meanwhile. Also check `node --version` is 18.17 or newer.

## Claude Desktop: the server fails to start

Claude Desktop runs `npx mcp-remote`, so Node.js must be installed and on the PATH that Claude Desktop sees. Check the `env` block holds `"JUSTCLAW_IT_AUTH": "Bearer <key>"` and the args list ends with `"Authorization:${JUSTCLAW_IT_AUTH}"` (no space after the colon). [Claude Desktop guide](/docs/clients/claude-desktop).

## The website says "Too many requests"

The site and the MCP endpoint rate-limit bursts per IP address. Slow down for a minute. If you hit it in normal use, email mike+mcpsupport@two7.design.

## Still stuck?

Check [/status](/status), then email mike+mcpsupport@two7.design with the time, the tool you called and the error text. Never send your full API key; the first few characters are enough.

---

URL: https://justclaw.it.com/docs/changelog

# Changelog

What changed in JustClaw-It MCP, newest first.

## 2026-10-27

- **Self-serve billing.** Cancel, update your card and see invoices from **Manage billing / Cancel** on your [account page](/account#billing). Sales tax is added at checkout where it applies (currently Texas).
- **Docs and blog.** New documentation with a page per client and per topic, every page available as Markdown (add `.md`), a "Copy page as Markdown" button, [/llms.txt](/llms.txt), [/llms-full.txt](/llms-full.txt), and a [blog](/blog) with an [RSS feed](/blog/rss.xml).
- **Free search, paid pulls.** `search_components`, `find_similar`, `list_categories`, `library_stats` and `list_licenses` now cost 0 credits. `get_component` stays at 1 credit. Searches are rate-limited per key and per network ([limits](/docs/credits#search-limits)).
- **Filters in the database.** `language`, `license` and `min_composite` filters now run inside the search query, so filtered searches return full pages and paging goes deeper (up to offset 450).
- **MCP App view.** Hosts that support MCP Apps show results and components in an interactive view ([MCP App view](/docs/mcp-app)).
- **Security advisories and reputation tiebreaker.** Results from repositories named in published CVE/GHSA advisories carry a `security_advisories` warning, kept out of the ranking. A small positive-only reputation signal breaks ties between well-known repositories ([Scores & ranking](/docs/scores)).
- **No overage on any plan.** Every plan is a hard cap; when credits run out, pulls stop until the next refill or an upgrade.
- **Legal pages final.** [Terms](/terms), [privacy](/privacy) and [refund policy](/refund) are final. JustClaw-It is a DBA of Two7 Design LLC; the terms are governed by Texas law.

## 2026-10-25

- **Paid plans.** Solo, Indie and Pro subscriptions with Stripe checkout; [pricing](/pricing) shows live plans.
- **JustClaw-It name.** The service, the MCP server entry (`justclaw-it`) and the skills now use the JustClaw-It name; the installer migrates older entries.
- **Status page.** [/status](/status) and [/status.json](/status.json).
- **Free-tier protection.** Signup checks and per-network limits to keep the free tier usable for real people.

## 2026-10-24

- **Pro tools.** `get_component_bundle` (3 credits) and `compose_starter` (10 credits).
- **Multiple keys on Pro** (up to 3).

## 2026-10-21

- **Licence gate.** The public library only serves permissive and weak-copyleft code. Every result carries an attribution block, returned source starts with an attribution header, and [/licenses](/licenses) lists every source repository.