# JsonFabrica (npm · @jsonfabrica/mcp-server)

Generate realistic, relational synthetic JSON test data from templates, via the JsonFabrica API.

- Trust score: 78/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-24

## Components

- npm · `@jsonfabrica/mcp-server`: 78/100 (this document), [markdown](https://verifymcp.io/servers/ms-methos-jsonfabrica-mcp-server/jsonfabrica-mcp-server.md), [page](https://verifymcp.io/servers/ms-methos-jsonfabrica-mcp-server/jsonfabrica-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `@jsonfabrica/mcp-server`
- Version: `0.3.0`
- Transport: `stdio`

## Trust breakdown

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

Scored 2026-09-24.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 95 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 15 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 71/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3734 tokens (~207/item across 18 items; 18 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 60/100
  - Stability check failed: the tool surface changed between 0.1.4 and 0.3.0: 2 tool removals, 0 breaking changes, 0 additions.
- **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.
  - Structured output schemas are declared (94% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 18 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

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

JsonFabrica runs locally as an npm package, launched with npx -y @jsonfabrica/mcp-server. 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 ms-methos-jsonfabrica-mcp-server -- npx -y @jsonfabrica/mcp-server
```

### Cursor

```json
{
  "mcpServers": {
    "ms-methos-jsonfabrica-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@jsonfabrica/mcp-server"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ms-methos-jsonfabrica-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@jsonfabrica/mcp-server"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ms-methos-jsonfabrica-mcp-server -- npx -y @jsonfabrica/mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ms-methos-jsonfabrica-mcp-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@jsonfabrica/mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ms-methos-jsonfabrica-mcp-server --command npx --arg -y --arg @jsonfabrica/mcp-server
```

### Hermes

```yaml
mcp_servers:
  ms-methos-jsonfabrica-mcp-server:
    command: "npx"
    args: ["-y", "@jsonfabrica/mcp-server"]
```

### Netclaw

```json
{
  "McpServers": {
    "ms-methos-jsonfabrica-mcp-server": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@jsonfabrica/mcp-server"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ms-methos-jsonfabrica-mcp-server -t stdio -c npx -a -y @jsonfabrica/mcp-server
```

### Other

```json
{
  "mcpServers": {
    "ms-methos-jsonfabrica-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@jsonfabrica/mcp-server"
      ]
    }
  }
}
```

## Changelog

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

### 2026-09-24 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 57 to 60.

### 2026-09-22 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 50 to 53.

### 2026-09-20 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47.

### 2026-09-18 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40.

### 2026-09-16 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33.

### 2026-09-14 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27.

### 2026-09-11 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17.

### 2026-09-09 (score 71, −1)

- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.17 → unverified
- [security regression] Stability: 0.17 → fail
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 0.2.0 → 0.3.0

## MCP tools (18)

### `jsonfabrica_health` (~43 tokens)

JsonFabrica health check

Calls GET /health on the JsonFabrica gateway. No authentication required. Use this to verify JSONFABRICA_API_URL points at a reachable gateway.

Output parameters:

- `service` (string): Name of the responding service, e.g. "svc-gateway".
- `status` (string): Liveness indicator, e.g. "ok".

### `jsonfabrica_whoami` (~51 tokens)

JsonFabrica whoami

Calls GET /v1/whoami on the JsonFabrica gateway using the configured API key. Returns { tenantId, role } for the configured JSONFABRICA_API_KEY.

Output parameters:

- `role` (string): Role associated with the configured API key.
- `tenantId` (string): Tenant id resolved from the configured API key.

### `jsonfabrica_create_template` (~367 tokens)

Create a JsonFabrica template

Calls POST /v1/templates. Creates a persisted, reusable template that can be generated from repeatedly with jsonfabrica_generate_from_template — use this instead of jsonfabrica_generate_adhoc when you want the body saved and shareable rather than a one-off, unsaved evaluation. `body` uses JsonFabrica's function-call placeholder syntax, e.g. "Hello {{getRandomFullName()}}" or "<getRandomNumber(1,100)>" — see the data-generation-functions reference for the full catalog. The optional `generate` field is a convenience that also runs a generation in the same call (response includes `generation` or `generationError` alongside `template`) so you avoid a separate jsonfabrica_generate_from_template round-trip; that generation is metered/billed and can advance durable sequences/variables just like a normal generate call. If `generate` is omitted, the response is just the created template with no generation side effects.

Input parameters:

- `body` (string, required): Template body containing at least one function-call placeholder. Required.
- `description` (string): Free-text human-readable description of the template's purpose. Optional; omitted means none stored.
- `generate` (object): When present, immediately generates one document from the just-created template using these options; the response then includes `generation`/`generationError` alongside `template`. Optional — omit to…
- `name` (string, required): Template name. Required; not required to be unique per tenant.
- `tags` (array): Labels for later filtering via jsonfabrica_list_templates' `tags` parameter (AND-match: a template must contain every requested tag). Optional; omitted or empty means no tags stored.

Output parameters:

- `astCache`: Server-internal parsed-body cache; opaque to callers.
- `body` (string): Template body containing function-call placeholders.
- `createdAt` (string): ISO-8601 creation timestamp.
- `description` (string|null): Free-text description, if any was stored.
- `generation` (object): Present when `generate` was passed and the immediate generation succeeded.
- `generationError` (object): Present when `generate` was passed but the immediate generation failed at runtime (template was still created).
- `name` (string): Template name.
- `status` (string): "active" unless soft-deleted via jsonfabrica_delete_template.
- `tags` (array): Tags stored on the template.
- `template` (object): Present when `generate` was passed; the created template record.
- `templateId` (string): Server-assigned template id.
- `tenantId` (string): Owning tenant id.
- `updatedAt` (string): ISO-8601 last-update timestamp.
- `validated` (boolean): Whether the body passed static template validation.
- `warnings` (array): Non-fatal validation warnings, if any.

### `jsonfabrica_list_templates` (~341 tokens)

List JsonFabrica templates

Calls GET /v1/templates. Returns a page of templates matching optional `name`/`tags`/`status` filters (`{ items, nextCursor }`). Use this to discover or search templates when you don't already know the `templateId`; if you already have the id, call jsonfabrica_get_template directly instead — it is cheaper and returns the full record. This is read-only and has no side effects. Pass `status: "archived"` to see templates previously removed with jsonfabrica_delete_template, since the default `active` filter excludes them.

Input parameters:

- `cursor` (string): Opaque pagination cursor taken verbatim from a previous response's `nextCursor`. Optional; omit to fetch the first page.
- `limit` (integer): Maximum number of templates to return in this page. Optional; defaults to 20 when omitted. Values <= 0 or > 100 are not clamped — the request is rejected with a 400 validation error.
- `name` (string): Filters to templates whose `name` contains this text — a case-insensitive substring match, not an exact match. Optional; omit to match templates of any name.
- `status` (string): `active` returns only non-deleted templates, `archived` returns only soft-deleted ones. Optional; defaults to `active` when omitted (archived templates are excluded unless requested).
- `tags` (string): Comma-separated list of tags, e.g. "orders,email". AND-match: a template must contain every listed tag to be included (not "any of"). Optional; omit to ignore tags entirely.

Output parameters:

- `items` (array): Page of matching templates.
- `nextCursor` (string): Pass to `cursor` on the next call to fetch the following page; absent on the last page.

### `jsonfabrica_get_template` (~141 tokens)

Get a JsonFabrica template

Calls GET /v1/templates/{templateId}. Returns the full template record for a known id. Use this instead of jsonfabrica_list_templates when you already have the `templateId` (e.g. from a prior create/list call); it is also the recommended way to inspect current `body`/`tags`/`description` before calling jsonfabrica_update_template, since update only shows you the fields you send, not the result of merging them with what already exists. Read-only, no side effects.

Input parameters:

- `templateId` (string, required): ID of the template to fetch, as returned by create/list. Required.

Output parameters:

- `astCache`: Server-internal parsed-body cache; opaque to callers.
- `body` (string): Template body containing function-call placeholders.
- `createdAt` (string): ISO-8601 creation timestamp.
- `description` (string|null): Free-text description, if any was stored.
- `name` (string): Template name.
- `status` (string): "active" unless soft-deleted via jsonfabrica_delete_template.
- `tags` (array): Tags stored on the template.
- `templateId` (string): Server-assigned template id.
- `tenantId` (string): Owning tenant id.
- `updatedAt` (string): ISO-8601 last-update timestamp.
- `validated` (boolean): Whether the body passed static template validation.
- `warnings` (array): Non-fatal validation warnings, if any.

### `jsonfabrica_update_template` (~281 tokens)

Update a JsonFabrica template

Calls PUT /v1/templates/{templateId}. Partially updates an existing template in place: only the fields you include in the call are changed, and every field you omit is left exactly as it was — call jsonfabrica_get_template first if you need to see current values before deciding what to send. Use this only for an existing `templateId`; to make a new template use jsonfabrica_create_template instead (it does not modify or version the original). The change is applied immediately and in-place with no version history — there is no undo, so if you need to keep the old `body`/`tags` around, read and save them first.

Input parameters:

- `body` (string): New template body (function-call placeholder syntax), replacing the existing one entirely. Optional; omit to leave the current body unchanged.
- `description` (string): New free-text description, replacing the existing one. Optional; omit to leave it unchanged.
- `name` (string): New template name. Optional; omit to leave the current name unchanged.
- `tags` (array): New full set of tags, replacing (not merging with) the existing tags. Optional; omit to leave the current tags unchanged; pass an empty array to clear all tags.
- `templateId` (string, required): ID of the template to update. Required.

Output parameters:

- `astCache`: Server-internal parsed-body cache; opaque to callers.
- `body` (string): Template body containing function-call placeholders.
- `createdAt` (string): ISO-8601 creation timestamp.
- `description` (string|null): Free-text description, if any was stored.
- `name` (string): Template name.
- `status` (string): "active" unless soft-deleted via jsonfabrica_delete_template.
- `tags` (array): Tags stored on the template.
- `templateId` (string): Server-assigned template id.
- `tenantId` (string): Owning tenant id.
- `updatedAt` (string): ISO-8601 last-update timestamp.
- `validated` (boolean): Whether the body passed static template validation.
- `warnings` (array): Non-fatal validation warnings, if any.

### `jsonfabrica_delete_template` (~164 tokens)

Delete a JsonFabrica template

Calls DELETE /v1/templates/{templateId}. This is a soft delete: the template's `status` is set to "archived" (it is not erased from storage), and the call returns the resulting archived template record. Archived templates are excluded from jsonfabrica_list_templates by default — pass `status: "archived"` there to find them again — and both jsonfabrica_get_template and jsonfabrica_generate_from_template still work against the id afterwards, since archiving does not block reads or generation. Use this when a template should stop showing up in normal listings; there is currently no tool to restore an archived template back to `active`.

Input parameters:

- `templateId` (string, required): ID of the template to delete. Required.

Output parameters:

- `astCache`: Server-internal parsed-body cache; opaque to callers.
- `body` (string): Template body containing function-call placeholders.
- `createdAt` (string): ISO-8601 creation timestamp.
- `description` (string|null): Free-text description, if any was stored.
- `name` (string): Template name.
- `status` (string): "active" unless soft-deleted via jsonfabrica_delete_template.
- `tags` (array): Tags stored on the template.
- `templateId` (string): Server-assigned template id.
- `tenantId` (string): Owning tenant id.
- `updatedAt` (string): ISO-8601 last-update timestamp.
- `validated` (boolean): Whether the body passed static template validation.
- `warnings` (array): Non-fatal validation warnings, if any.

### `jsonfabrica_generate_from_template` (~380 tokens)

Generate a document from a JsonFabrica template

Calls POST /v1/templates/{templateId}/generate. Generates a document from a persisted, saved template referenced by `templateId` — use this (not jsonfabrica_generate_adhoc) when the template is meant to be reused or shared across calls/tenants; use jsonfabrica_generate_adhoc instead when you are still iterating on raw template syntax and don't want to persist anything yet. This call is metered/billed like any generation and, unless namespaced, can advance real durable sequences and mutate durable variables referenced by the template body. Set `sequenceNamespace`/`variableNamespace` to isolate those side effects between environments (e.g. test vs. production).

Input parameters:

- `context` (object): Arbitrary auxiliary key/value data made available to the template body alongside `params`. Optional; omitted keys are simply absent during generation.
- `params` (object): Key/value map supplying values for getParam("key") placeholders in the template body. Optional; omitted keys leave the corresponding getParam() calls unresolved/empty.
- `seed` (number): Deterministic PRNG seed for this generation — the same seed reproduces byte-identical random values. Optional; if omitted the server picks a random seed and returns it in the response.
- `sequenceNamespace` (string): Isolates createSeq()/getSeq() durable-sequence side effects under this namespace so repeated test/debug runs don't advance real tenant sequences. Optional; omitted means the default (unnamespaced) se…
- `templateId` (string, required): ID of the persisted template to generate a document from. Required.
- `variableNamespace` (string): Isolates durable-variable side effects under this namespace, analogous to `sequenceNamespace`. Optional; omitted means the default (unnamespaced) variable scope is used.

Output parameters:

- `data`: The generated document; shape is entirely determined by the template body.
- `meta` (object): Generation metadata.

### `jsonfabrica_generate_adhoc` (~387 tokens)

Generate a document from a raw template body (no persistence)

Calls POST /v1/templates/generate. Generates a document directly from a raw `body` string without creating a template record — prefer this over jsonfabrica_generate_from_template while still iterating on template syntax; switch to jsonfabrica_create_template once the body is ready to be reused or shared. Goes through the same billing/usage metering as persisted-template generation (not a free bypass). createSeq()/durable sequence side effects still apply; set `sequenceNamespace`/`variableNamespace` to e.g. "debug" to avoid colliding with real tenant sequences and variables.

Input parameters:

- `body` (string, required): Raw template body containing at least one function-call placeholder, e.g. "Hello {{getRandomFullName()}}" — evaluated directly without persisting a template record. Required.
- `context` (object): Arbitrary auxiliary key/value data made available to `body` alongside `params`. Optional; omitted keys are simply absent during generation.
- `params` (object): Key/value map supplying values for getParam("key") placeholders in `body`. Optional; omitted keys leave the corresponding getParam() calls unresolved/empty.
- `seed` (number): Deterministic PRNG seed for this generation — the same seed reproduces byte-identical random values. Optional; if omitted the server picks a random seed and returns it in the response.
- `sequenceNamespace` (string): Isolates createSeq()/getSeq() durable-sequence side effects under this namespace, e.g. "debug", so ad-hoc runs don't advance real tenant sequences. Optional; omitted means the default (unnamespaced)…
- `variableNamespace` (string): Isolates durable-variable side effects under this namespace, analogous to `sequenceNamespace`. Optional; omitted means the default (unnamespaced) variable scope is used.

Output parameters:

- `data`: The generated document; shape is entirely determined by the template body.
- `meta` (object): Generation metadata.

### `jsonfabrica_create_sequence` (~361 tokens)

Create a JsonFabrica sequence

Calls POST /v1/sequences. Creates a durable named sequence (number/string/uuid), referenced from template bodies via createSeq()/getSeq()-style functions. Fails with a 409-style conflict error if a sequence with this `name` already exists for the tenant — use jsonfabrica_update_sequence to change an existing one's `currentValue`/`step` instead of retrying create with the same name.

Input parameters:

- `name` (string, required): Unique identifier for the sequence within the tenant, referenced from template bodies via createSeq("name")/getSeq("name") placeholders. Required; creation fails if a sequence with this name already…
- `start` (number): Initial value of `currentValue` for "number"/"string" sequences. Marked optional in this schema, but the gateway validates it as a required finite number for every sequence type — omitting it always…
- `step` (number): Amount `currentValue` is incremented by on each bump, for "number"/"string" sequences (ignored for "uuid"). Optional; defaults to 1 when omitted. May be negative to count down.
- `type` (string, required): Value kind the sequence produces on each bump: "number" increments `currentValue` by `step` and returns a numeric value; "string" behaves like "number" but the returned value is stringified; "uuid" d…

Output parameters:

- `createdAt` (string): ISO-8601 creation timestamp.
- `currentValue` (number): Current stored counter value (unused by "uuid" sequences).
- `name` (string): Sequence name.
- `start` (number): Initial value the sequence was created with.
- `step` (number): Increment applied per bump (ignored for "uuid").
- `tenantId` (string): Owning tenant id.
- `type` (string): Value kind produced on each bump.
- `updatedAt` (string): ISO-8601 last-update timestamp.

### `jsonfabrica_list_sequences` (~158 tokens)

List JsonFabrica sequences

Calls GET /v1/sequences. Returns a page of sequences (`{ items, nextCursor }`). Use this to discover sequence names when you don't already know one; if you know the exact `name`, call jsonfabrica_get_sequence directly instead. Read-only, no side effects.

Input parameters:

- `cursor` (string): Opaque pagination cursor from a previous response's `nextCursor`. Optional; omit to fetch the first page. Not a page number or offset you construct yourself.
- `limit` (integer): Maximum number of sequences to return in this page. Optional; defaults to 20 when omitted. Values <= 0 or > 100 are not clamped — the request is rejected with a 400 validation error.

Output parameters:

- `items` (array): Page of matching sequences.
- `nextCursor` (string): Pass to `cursor` on the next call; absent on the last page.

### `jsonfabrica_get_sequence` (~88 tokens)

Get a JsonFabrica sequence

Calls GET /v1/sequences/{name}. Returns the sequence record for a known `name`; use jsonfabrica_list_sequences instead if you need to discover names. Read-only — does not advance the sequence (use jsonfabrica_bump_sequence for that).

Input parameters:

- `name` (string, required): Exact name of the sequence to fetch, as given at creation. Required.

Output parameters:

- `createdAt` (string): ISO-8601 creation timestamp.
- `currentValue` (number): Current stored counter value (unused by "uuid" sequences).
- `name` (string): Sequence name.
- `start` (number): Initial value the sequence was created with.
- `step` (number): Increment applied per bump (ignored for "uuid").
- `tenantId` (string): Owning tenant id.
- `type` (string): Value kind produced on each bump.
- `updatedAt` (string): ISO-8601 last-update timestamp.

### `jsonfabrica_update_sequence` (~229 tokens)

Update a JsonFabrica sequence

Calls PATCH /v1/sequences/{name}. Only the provided fields (currentValue, step) are changed; fields you omit are left as-is. Use this when you need to set an explicit `currentValue` (e.g. resetting a counter) or change the `step` amount — use jsonfabrica_bump_sequence instead when you just want to advance the sequence by its existing configured step. This overwrites the sequence's stored state in place immediately; there is no undo.

Input parameters:

- `currentValue` (number): Resets the sequence's current counter value to this number, without changing `step`. Optional; if omitted, the current value is left unchanged (unless `step` is also provided, in which case only `ste…
- `name` (string, required): Exact name of the sequence to update. Required.
- `step` (number): Changes the increment applied by future jsonfabrica_bump_sequence calls; must be a non-zero finite number (negative allowed, to count down). Optional; if omitted, the existing step is left unchanged.

Output parameters:

- `createdAt` (string): ISO-8601 creation timestamp.
- `currentValue` (number): Current stored counter value (unused by "uuid" sequences).
- `name` (string): Sequence name.
- `start` (number): Initial value the sequence was created with.
- `step` (number): Increment applied per bump (ignored for "uuid").
- `tenantId` (string): Owning tenant id.
- `type` (string): Value kind produced on each bump.
- `updatedAt` (string): ISO-8601 last-update timestamp.

### `jsonfabrica_delete_sequence` (~116 tokens)

Delete a JsonFabrica sequence

Calls DELETE /v1/sequences/{name}. This is a hard, permanent delete — unlike jsonfabrica_delete_template's soft-delete/archive behavior, the sequence record is removed entirely and cannot be recovered; there is no `status: "archived"` equivalent for sequences. Returns no content on success. Any template body still calling createSeq()/getSeq() with this `name` afterwards will no longer see the deleted history/state.

Input parameters:

- `name` (string, required): Exact name of the sequence to delete. Required.

### `jsonfabrica_bump_sequence` (~128 tokens)

Bump a JsonFabrica sequence

Calls POST /v1/sequences/{name}/bump. Atomically advances the sequence by its configured `step` (a permanent, irreversible change to the stored `currentValue`) and returns the updated record — this is the same advance a template's createSeq()/getSeq() calls trigger during generation. Use jsonfabrica_update_sequence instead if you need to set an explicit `currentValue`/`step` rather than advancing by the existing step.

Input parameters:

- `name` (string, required): Exact name of the sequence to bump (advance by its configured step). Required.

Output parameters:

- `createdAt` (string): ISO-8601 creation timestamp.
- `currentValue` (number): Current stored counter value (unused by "uuid" sequences).
- `name` (string): Sequence name.
- `start` (number): Initial value the sequence was created with.
- `step` (number): Increment applied per bump (ignored for "uuid").
- `tenantId` (string): Owning tenant id.
- `type` (string): Value kind produced on each bump.
- `updatedAt` (string): ISO-8601 last-update timestamp.

### `jsonfabrica_create_batch` (~386 tokens)

Create a JsonFabrica batch generation job

Calls POST /v1/batches. Generates multiple documents from one or more persisted templates in one call, optionally cross-referencing documents via `relations` — use this instead of looping jsonfabrica_generate_from_template yourself when you need many documents or cross-document relations in a single request. Small batches run synchronously and the response is 200 with `results`; larger batches are queued and the response is 202 with just `{ batchId, status, seed }` — poll jsonfabrica_get_batch for the final results in that case. Like a single generate call, this is metered/billed per document produced and, unless namespaced, can advance real durable sequences and mutate durable variables referenced by the templates.

Input parameters:

- `documents` (array, required): One entry per group of documents to generate, each naming a `templateId`, a unique `alias`, how many (`count`) to generate, and optionally `relations`/`params`. Required; at least one entry. Entries…
- `seed` (number): Deterministic PRNG seed applied across the whole batch — the same seed reproduces byte-identical random values for every document. Optional; if omitted the server picks a random seed and returns it i…
- `sequenceNamespace` (string): Isolates createSeq()/getSeq() durable-sequence side effects for this whole batch under this namespace, so test/debug runs don't advance real tenant sequences. Optional; omitted means the default (unn…
- `variableNamespace` (string): Isolates durable-variable side effects for this whole batch under this namespace, analogous to `sequenceNamespace`. Optional; omitted means the default (unnamespaced) variable scope is used.

Output parameters:

- `batchId` (string): Id of the created batch.
- `error` (object): Present if the whole batch failed.
- `results` (array): Present only for synchronous (200) responses.
- `seed` (number): PRNG seed used/assigned for the whole batch.
- `status` (string): Batch status at response time.

### `jsonfabrica_get_batch` (~75 tokens)

Get a JsonFabrica batch

Calls GET /v1/batches/{batchId}. Returns batch status and, once complete, the generated documents. Use this to poll a batch that was accepted asynchronously (202).

Input parameters:

- `batchId` (string, required): ID of the batch job to fetch, as returned by jsonfabrica_create_batch. Required.

Output parameters:

- `batchId` (string): Id of the fetched batch.
- `documents` (array): Generated documents, once available.
- `error` (object): Present if the whole batch failed.
- `seed` (number): PRNG seed used for the whole batch.
- `spec`: The original BatchSpec request body this batch was created from.
- `status` (string): Current batch status.
- `tenantId` (string): Owning tenant id.

### `jsonfabrica_get_usage` (~38 tokens)

Get JsonFabrica tenant usage

Calls GET /v1/usage. Returns `{ tenantId, usageTotal, asOf }` for the configured API key.

Output parameters:

- `asOf` (string): ISO-8601 timestamp the usage total was computed as of.
- `tenantId` (string): Tenant id the usage totals belong to.
- `usageTotal` (number): Cumulative metered usage units consumed by this tenant.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ms-methos-jsonfabrica-mcp-server/jsonfabrica-mcp-server#diagnostics

## Score history

- 2026-09-24: 78
- 2026-09-23: 77
- 2026-09-22: 77
- 2026-09-21: 76
- 2026-09-20: 76
- 2026-09-19: 75
- 2026-09-18: 75
- 2026-09-17: 74
- 2026-09-16: 74
- 2026-09-15: 73
- 2026-09-14: 73
- 2026-09-13: 72
- 2026-09-12: 72
- 2026-09-11: 72
- 2026-09-10: 71
- 2026-09-09: 71
- 2026-09-08: 72
- 2026-09-07: 56
- 2026-09-06: 64
- 2026-09-05: 64
- 2026-09-04: 64
- 2026-09-03: 64

## Common questions

### What is the JsonFabrica MCP server?

JsonFabrica is an MCP server listed in the public MCP registry as io.github.ms-methos/jsonfabrica-mcp-server. Generate realistic, relational synthetic JSON test data from templates, via the JsonFabrica API. This page covers its npm package (@jsonfabrica/mcp-server).

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

JsonFabrica scores 78 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 24 September 2026. It declares no install or post-install scripts. 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 JsonFabrica MCP server expose?

JsonFabrica exposes 18 tools: jsonfabrica_health, jsonfabrica_whoami, jsonfabrica_create_template, jsonfabrica_list_templates, jsonfabrica_get_template, and 13 more. Their descriptions and schemas cost roughly 3,734 tokens of context every time the server is loaded.

### Is the JsonFabrica MCP server still maintained?

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

### What licence is the JsonFabrica MCP server under?

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

## Links

- npm package: https://www.npmjs.com/package/@jsonfabrica/mcp-server
- Socket report: https://socket.dev/npm/package/@jsonfabrica/mcp-server
- Repository: https://github.com/ms-methos/jsonfabrica-mcp-server
- Website: https://jsonfabrica.com/
- Changelog RSS feed: https://verifymcp.io/servers/ms-methos-jsonfabrica-mcp-server/jsonfabrica-mcp-server.xml
- Changelog JSON feed: https://verifymcp.io/servers/ms-methos-jsonfabrica-mcp-server/jsonfabrica-mcp-server.json
- HTML version of this page: https://verifymcp.io/servers/ms-methos-jsonfabrica-mcp-server/jsonfabrica-mcp-server