{
  "notice": "bxzxxr MCP archive: a record of what public MCP servers declared when we listed them (we never call their tools). It is data, not a rating: nothing here says a server is safe, secure, verified or trustworthy, and a server can change after we looked. Secrets we detected are redacted; redacted tool lists are withheld and only their hash is shown.",
  "infrastructure": {
    "host": "mcp.jsonpad.io",
    "site": "jsonpad.io",
    "addresses": [
      {
        "address": "52.3.158.198",
        "endpoints": 2,
        "shared_infrastructure": false,
        "network": {
          "asn": 16509,
          "name": "AMAZON-02 - Amazon.com, Inc.",
          "prefix": "52.0.0.0/11",
          "country": "US"
        }
      }
    ],
    "addresses_recorded": true,
    "address_history": [
      {
        "addresses": [
          "52.3.158.198"
        ],
        "first_seen": "2026-11-21T17:48:00.618Z",
        "last_seen": "2026-11-21T17:48:00.618Z",
        "checks": 1
      }
    ],
    "hosting": [],
    "software": [
      {
        "value": "nginx",
        "evidence": "Server header \"nginx/1.24.0 (Ubuntu)\""
      }
    ],
    "server_info": {
      "name": "jsonpad-docs",
      "version": "0.1.0",
      "protocol_version": "2025-06-18"
    },
    "headers": {
      "server": "nginx/1.24.0 (Ubuntu)",
      "access-control-allow-origin": "*"
    },
    "auth": null
  },
  "related": {
    "same_address": {
      "total": 1,
      "sample": [
        {
          "id": "41323",
          "url": "https://mcp.jsonpad.io/api",
          "server_name": "io.jsonpad/api",
          "last_state": "auth_required",
          "last_checked_at": "2026-11-21T17:47:02.281Z"
        }
      ]
    },
    "same_site": {
      "total": 1,
      "sample": [
        {
          "id": "41323",
          "url": "https://mcp.jsonpad.io/api",
          "server_name": "io.jsonpad/api",
          "last_state": "auth_required",
          "last_checked_at": "2026-11-21T17:47:02.281Z"
        }
      ]
    },
    "same_tool_list": {
      "total": 0,
      "sample": []
    },
    "same_publisher": {
      "publisher": "io.jsonpad",
      "total": 1,
      "sample": [
        {
          "name": "io.jsonpad/api",
          "title": "JSONPad"
        }
      ]
    },
    "same_repository": null,
    "note": "Shared addresses on big platforms (Cloudflare, Vercel and the like) put unrelated servers together; those are marked shared_infrastructure. A match is a pivot, not a link between operators."
  },
  "endpoint": {
    "id": "41324",
    "server_name": "io.jsonpad/docs",
    "url": "https://mcp.jsonpad.io/docs",
    "host": "mcp.jsonpad.io",
    "transport": "streamable-http",
    "last_checked_at": "2026-11-21T17:48:00.618Z",
    "last_state": "listed",
    "last_detail": null,
    "consecutive_failures": 0,
    "current_sha": "e2fcb844dcf529098bbd606f57a1783298092eec5d968b9a8a51a1bfd15c7cd6",
    "first_listed_at": "2026-11-21T17:48:00.618Z",
    "created_at": "2026-11-21T12:25:08.455Z",
    "resolved_addresses": [
      "52.3.158.198"
    ]
  },
  "server": {
    "name": "io.jsonpad/docs",
    "title": "JSONPad documentation",
    "description": "JSONPad docs, API, SDK and CLI references, and offline checkers for write rules and flows.",
    "version": "0.1.0",
    "registry_status": "active",
    "repository_url": null,
    "website_url": "https://jsonpad.io/docs/mcp",
    "published_at": "2026-09-30T20:20:57.447Z",
    "updated_at": "2026-09-30T20:20:57.447Z",
    "first_seen": "2026-11-21T12:25:07.789Z"
  },
  "other_endpoints": [],
  "intel": {
    "capabilities": [
      "runs-code",
      "vector-search"
    ],
    "evm_addresses": [],
    "chains": [],
    "tokens": [],
    "computed_at": "2026-11-22T15:55:07.477Z"
  },
  "operator": {
    "key": "jsonpad.io",
    "name": "jsonpad.io",
    "platform": false
  },
  "needs_sign_in": false,
  "reachability": {
    "window_days": 30,
    "checks": 1,
    "answered": 1,
    "answered_percent": 100,
    "avg_listing_latency_ms": 140,
    "first_check_in_window": "2026-11-21T17:48:00.618Z",
    "consecutive_failures_now": 0,
    "days": [
      {
        "day": "2026-11-21",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      }
    ]
  },
  "tool_list": {
    "sha256": "e2fcb844dcf529098bbd606f57a1783298092eec5d968b9a8a51a1bfd15c7cd6",
    "tools": 14,
    "resources": 124,
    "prompts": 7,
    "first_seen": "2026-11-21T17:48:00.763Z",
    "tool_names": [
      "search_docs",
      "read_doc",
      "list_docs",
      "list_api_endpoints",
      "get_api_endpoint",
      "get_sdk_method",
      "get_cli_command",
      "lookup_error",
      "get_plan_limits",
      "check_write_rules",
      "eval_write_rule",
      "check_flow",
      "validate_sync_document",
      "validate_token_permissions"
    ],
    "declared": {
      "tools": [
        {
          "name": "search_docs",
          "title": "Search the JSONPad docs",
          "description": "Search the JSONPad documentation, the JavaScript SDK references and the command line tool reference. Returns the best-matching sections with a snippet and their jsonpad.io URL; read one with read_doc. Exact identifiers work well: error codes and names, headers, SDK methods, CLI commands, $jsonpad-var variables, \"POST /lists/{listId}/items\".",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "query"
            ],
            "properties": {
              "limit": {
                "type": "integer",
                "default": 5,
                "maximum": 10,
                "minimum": 1,
                "description": "How many results (1-10)"
              },
              "query": {
                "type": "string",
                "maxLength": 200,
                "minLength": 2,
                "description": "What to look for"
              },
              "section": {
                "enum": [
                  "guides",
                  "api-reference",
                  "lists",
                  "items",
                  "indexes",
                  "identities",
                  "tokens",
                  "flows",
                  "schema-sync",
                  "sdk",
                  "cli"
                ],
                "type": "string",
                "description": "Only search one section: guides, api-reference (every API reference section), lists, items, indexes, identities, tokens, flows, schema-sync, sdk or cli"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "results"
            ],
            "properties": {
              "results": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "read_doc",
          "title": "Read a JSONPad docs page",
          "description": "Read a documentation page as markdown, or one section of it. Give a page slug (\"indexing\"), a /docs path, a jsonpad.io URL (with or without .md, and with an optional #anchor), \"sdk/jsonpad-sdk\", \"sdk/jsonpad-realtime-sdk\", \"cli/reference\" or \"cli/readme\". Long pages are cut at a section boundary; read on with the returned nextSection.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "page"
            ],
            "properties": {
              "page": {
                "type": "string",
                "minLength": 1,
                "description": "The page: a slug, path or URL"
              },
              "section": {
                "type": "string",
                "description": "A heading anchor (\"filtering-items\") or heading text; overrides a #anchor in page"
              },
              "maxChars": {
                "type": "integer",
                "default": 20000,
                "maximum": 100000,
                "minimum": 1000,
                "description": "The most characters of markdown to return"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "title",
              "url",
              "markdown",
              "truncated"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "title": {
                "type": "string"
              },
              "markdown": {
                "type": "string"
              },
              "truncated": {
                "type": "boolean"
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_docs",
          "title": "List the JSONPad docs pages",
          "description": "List the documentation pages by section, with a description of each: the table of contents.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "section": {
                "enum": [
                  "guides",
                  "api-reference",
                  "lists",
                  "items",
                  "indexes",
                  "identities",
                  "tokens",
                  "flows",
                  "schema-sync",
                  "sdk",
                  "cli"
                ],
                "type": "string",
                "description": "Only list one section"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "sections"
            ],
            "properties": {
              "sections": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_api_endpoints",
          "title": "List the JSONPad API endpoints",
          "description": "List the REST API endpoints an API token can use, as method, path and title. Get one in full with get_api_endpoint.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "resource": {
                "enum": [
                  "lists",
                  "items",
                  "indexes",
                  "identities",
                  "tokens",
                  "flows",
                  "schema-sync"
                ],
                "type": "string",
                "description": "Only one resource"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "endpoints"
            ],
            "properties": {
              "endpoints": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_api_endpoint",
          "title": "Get a JSONPad API endpoint contract",
          "description": "The full contract of one REST API endpoint: parameters, headers, request body, responses and examples, and the JavaScript SDK method that calls it. Find it by id (the docs page slug, e.g. \"item-restore\"), by method and path (templates or concrete paths both work: \"/lists/my-list/items/abc\"), or by a description.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "id": {
                "type": "string",
                "description": "The endpoint id, from list_api_endpoints"
              },
              "path": {
                "type": "string",
                "description": "The path, e.g. /lists/{listId}/items"
              },
              "query": {
                "type": "string",
                "description": "What the endpoint does, e.g. \"restore a deleted item\""
              },
              "method": {
                "enum": [
                  "GET",
                  "POST",
                  "PUT",
                  "PATCH",
                  "DELETE",
                  "ANY"
                ],
                "type": "string",
                "description": "The HTTP method"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "endpoint"
            ],
            "properties": {
              "endpoint": {
                "type": "object",
                "additionalProperties": {}
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_sdk_method",
          "title": "Get a JSONPad SDK method",
          "description": "The signature, description and example of a method in the JavaScript SDK (@basementuniverse/jsonpad-sdk) or the realtime SDK, and the REST endpoint it calls. Find it by name (\"restoreItem\") or by what it does.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "name": {
                "type": "string",
                "description": "The method name, e.g. restoreItem"
              },
              "query": {
                "type": "string",
                "description": "What the method does, e.g. \"wait for an index to build\""
              },
              "package": {
                "enum": [
                  "jsonpad-sdk",
                  "jsonpad-realtime-sdk"
                ],
                "type": "string",
                "description": "Only one package"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "method"
            ],
            "properties": {
              "method": {
                "type": "object",
                "additionalProperties": {}
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_cli_command",
          "title": "Get a JSONPad CLI command",
          "description": "The usage, arguments and options of a jsonpad command line tool (@basementuniverse/jsonpad-cli) command, and whether it works offline. Find it by name (\"rules test\", \"jsonpad sync-schema --dry-run\") or by what it does.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "name": {
                "type": "string",
                "description": "The command, e.g. \"sync-schema\" or \"jsonpad rules test\""
              },
              "query": {
                "type": "string",
                "description": "What the command does, e.g. \"export items to a file\""
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "command"
            ],
            "properties": {
              "command": {
                "type": "object",
                "additionalProperties": {}
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "lookup_error",
          "title": "Look up a JSONPad error",
          "description": "What a JSONPad API error code means, its HTTP status, and the guides that explain it. Give the numeric code (10013) or the name (QUOTA_EXCEEDED), as found in an error response's \"code\" and \"name\".",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "code": {
                "type": "integer",
                "description": "The numeric code, e.g. 10013"
              },
              "name": {
                "type": "string",
                "description": "The name, e.g. QUOTA_EXCEEDED"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "error"
            ],
            "properties": {
              "error": {
                "type": "object",
                "additionalProperties": {}
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_plan_limits",
          "title": "Get JSONPad plan limits",
          "description": "The limits of each public plan (Free, Indie, Pro, Scale): requests per month and minute, the minimum gap between requests, storage, item size, versions kept, tokens, identities, realtime connections, webhooks and flows. null means unlimited. Sizes are in bytes, rateLimit in milliseconds, prices in GBP.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "properties": {
              "plan": {
                "type": "string",
                "description": "One plan, by id or name, e.g. \"free\""
              },
              "limit": {
                "enum": [
                  "maxRequestsPerMonth",
                  "overdraftPercent",
                  "maxRequestsPerMinute",
                  "rateLimit",
                  "maxStorageBytes",
                  "maxLists",
                  "maxItemsPerList",
                  "maxIndexesPerList",
                  "maxItemSize",
                  "maxItemVersions",
                  "maxTokens",
                  "maxIdentities",
                  "maxRealtimeConnections",
                  "maxWebhooks",
                  "maxFlows"
                ],
                "type": "string",
                "description": "One limit, e.g. maxItemSize"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "plans"
            ],
            "properties": {
              "plans": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "check_write_rules",
          "title": "Check write rules",
          "description": "Compile a list's write rules with the same engine the API uses, and run their tests (a rules-tests-v1 document). Returns every diagnostic with its line and column, and for each failing test what it expected, what happened, and how each rule came out. Costs nothing and sees no data: lookups find the test document's items. Use it before saving rules.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "rules"
            ],
            "properties": {
              "rules": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  }
                ],
                "description": "The rule text, or its lines as an array (as in a schema sync document)"
              },
              "tests": {
                "anyOf": [
                  {
                    "type": "object",
                    "additionalProperties": {}
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "The rule tests: a rules-tests-v1 document ({ \"tests\": [...] }), optional"
              },
              "knownLists": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Path names of lists that exist, so lookups into any other list are warned about, as the API does when rules are saved"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "ok",
              "diagnostics"
            ],
            "properties": {
              "ok": {
                "type": "boolean"
              },
              "diagnostics": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "eval_write_rule",
          "title": "Try a write against write rules",
          "description": "Check one write against a rule set, as the API would, and say whether it would be allowed, denied (403) or failed (400), which statement decided it, and (with trace) what every expression evaluated to. The write is shaped like a rule test case: action, identity, token, old, new, patch, merge, now. Costs nothing and sees no data.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "rules",
              "write"
            ],
            "properties": {
              "items": {
                "type": "object",
                "description": "Items for lookups to find: { \"<list>\": { \"<item id or alias>\": { \"data\": ... } } }",
                "additionalProperties": {}
              },
              "rules": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  }
                ],
                "description": "The rule text, or its lines as an array (as in a schema sync document)"
              },
              "trace": {
                "type": "boolean",
                "default": false,
                "description": "Include the value of every expression"
              },
              "write": {
                "type": "object",
                "required": [
                  "action"
                ],
                "properties": {
                  "new": {
                    "description": "The item data after the write"
                  },
                  "now": {
                    "type": "string",
                    "description": "The time of the write, ISO 8601"
                  },
                  "old": {
                    "description": "The item data before the write (not for create)"
                  },
                  "merge": {
                    "description": "A merge applied to old, instead of new"
                  },
                  "patch": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "additionalProperties": {}
                    },
                    "description": "A JSON Patch applied to old, instead of new"
                  },
                  "token": {
                    "type": "object",
                    "description": "The API token, e.g. { \"id\": \"t1\", \"tags\": [\"writer\"] }",
                    "additionalProperties": {}
                  },
                  "action": {
                    "enum": [
                      "create",
                      "update",
                      "delete",
                      "restore"
                    ],
                    "type": "string"
                  },
                  "identity": {
                    "description": "The identity making the write: { \"id\": \"...\" }, a key into identities, or null"
                  }
                },
                "description": "The write to check",
                "additionalProperties": true
              },
              "identities": {
                "type": "object",
                "description": "Named identities the write can refer to",
                "additionalProperties": {}
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "ok"
            ],
            "properties": {
              "ok": {
                "type": "boolean"
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "check_flow",
          "title": "Check a flow",
          "description": "Compile a flow document (flows-v1) with the same engine the API uses, and run its tests (flow-tests-v1) against in-memory data. Returns diagnostics (with JSON pointers into the document), what the flow reads and writes, and why each failing test failed. Costs nothing and sees no data.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "flow"
            ],
            "properties": {
              "flow": {
                "anyOf": [
                  {
                    "type": "object",
                    "additionalProperties": {}
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "The flow document"
              },
              "tests": {
                "anyOf": [
                  {
                    "type": "object",
                    "additionalProperties": {}
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "The flow tests: a flow-tests-v1 document, optional"
              },
              "knownLists": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Path names of lists that exist, so the flow using any other list is warned about"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "ok",
              "diagnostics"
            ],
            "properties": {
              "ok": {
                "type": "boolean"
              },
              "diagnostics": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "validate_sync_document",
          "title": "Validate a schema sync document",
          "description": "Check a schema sync document (sync-v1) as far as possible without an account: against the JSON schema the API uses, the API's rules for keys and indexes, and every rule set and flow in it with their tests. Documents that reference files (rulesFile, flowFile and their tests) are checked too if the files' contents are given in files. What a sync would change needs the account: the API server's plan_schema_sync, or jsonpad sync-schema --dry-run.",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "document"
            ],
            "properties": {
              "files": {
                "type": "object",
                "description": "The contents of files the document references, keyed by the path written in the document, e.g. { \"rules/games.rules\": \"allow ...\" }",
                "additionalProperties": {
                  "type": "string"
                }
              },
              "document": {
                "anyOf": [
                  {
                    "type": "object",
                    "additionalProperties": {}
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "The schema sync document"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "ok",
              "problems"
            ],
            "properties": {
              "ok": {
                "type": "boolean"
              },
              "problems": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {}
                }
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "validate_token_permissions",
          "title": "Validate token permissions",
          "description": "Check an API token's permission rules against the schema the API uses, say which rule shape a broken one was meant to be, and warn about valid rules that probably don't do what was meant (rule order, restore without view, sync-schema alone, allow \"*\").",
          "inputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "permissions"
            ],
            "properties": {
              "permissions": {
                "anyOf": [
                  {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "additionalProperties": {}
                    }
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "The permission rules, e.g. [{ \"mode\": \"allow\", \"action\": \"view\", \"resourceType\": \"item\", \"listIds\": [\"*\"], \"itemIds\": [\"*\"] }]"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "http://json-schema.org/draft-07/schema#",
            "required": [
              "ok"
            ],
            "properties": {
              "ok": {
                "type": "boolean"
              }
            },
            "additionalProperties": true
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        }
      ],
      "tools_omitted": 0,
      "resources": [
        {
          "name": "cli",
          "uri": "jsonpad-docs://cli",
          "mimeType": "text/markdown",
          "description": "Every command and option of the jsonpad command line tool"
        },
        {
          "name": "llms-txt",
          "uri": "jsonpad-docs://llms.txt",
          "mimeType": "text/markdown",
          "description": "An index of the documentation, with a line per page"
        },
        {
          "name": "llms-full-txt",
          "uri": "jsonpad-docs://llms-full.txt",
          "mimeType": "text/markdown",
          "description": "Every documentation page, concatenated. Large (about 600 KB): prefer search_docs and read_doc"
        },
        {
          "name": "endpoints",
          "uri": "jsonpad-docs://endpoints",
          "mimeType": "application/json",
          "description": "Every REST API endpoint contract, as JSON"
        },
        {
          "name": "errors",
          "uri": "jsonpad-docs://errors",
          "mimeType": "application/json",
          "description": "Every documented error code, as JSON"
        },
        {
          "name": "plans",
          "uri": "jsonpad-docs://plans",
          "mimeType": "application/json",
          "description": "Each public plan's limits, as JSON"
        },
        {
          "name": "Documentation",
          "uri": "jsonpad-docs://pages/docs",
          "mimeType": "text/markdown",
          "description": "jsonpad.io is a JSON storage platform with a RESTful API which allows you to store and retrieve your data in various ways."
        },
        {
          "name": "Getting started",
          "uri": "jsonpad-docs://pages/getting-started",
          "mimeType": "text/markdown",
          "description": "This tutorial will walk you through creating a list and some items, then fetching those items and updating them. These operations form the basis of what jsonpad.io does, and will probably be the most common things you'll need to do when building with jsonpad.io."
        },
        {
          "name": "Talking to the API",
          "uri": "jsonpad-docs://pages/talking-to-the-api",
          "mimeType": "text/markdown",
          "description": "You can interact directly with the API using any progamming language or platform capable of making HTTP requests, or you can use client libraries (SDKs) which make it even easier to integrate jsonpad.io into your projects. Right now there's only a Javascript SDK, but more are on the way!"
        },
        {
          "name": "List schemas",
          "uri": "jsonpad-docs://pages/list-schemas",
          "mimeType": "text/markdown",
          "description": "By default when you create an item in a list, you can add any JSON data you like. However, let's say you want to enforce a specific structure on the data that is stored in a list. This is where list schemas come in."
        },
        {
          "name": "Indexing lists",
          "uri": "jsonpad-docs://pages/indexing",
          "mimeType": "text/markdown",
          "description": "Each list can contain multiple indexes. These indexes are used to efficiently sort, filter, and search items in the list."
        },
        {
          "name": "Paths and pointers",
          "uri": "jsonpad-docs://pages/paths-and-pointers",
          "mimeType": "text/markdown",
          "description": "Most of the endpoints for interacting with Items have support for JSON path and JSON pointer expressions which allow you to dig into your data and fetch or update specific parts of an item's data."
        },
        {
          "name": "Token permissions",
          "uri": "jsonpad-docs://pages/token-permissions",
          "mimeType": "text/markdown",
          "description": "Tokens are the primary way to authenticate with the API. They can be given permissions to access specific resources."
        },
        {
          "name": "Tags",
          "uri": "jsonpad-docs://pages/tags",
          "mimeType": "text/markdown",
          "description": "If you use JSONPad for more than one app, your lists, tokens and identities for all of those apps end up side by side. Tags let you group related resources together, so you can quickly find everything that belongs to one of your apps."
        },
        {
          "name": "Identity groups",
          "uri": "jsonpad-docs://pages/identity-groups",
          "mimeType": "text/markdown",
          "description": "Every identity belongs to a group. Groups keep the identities for different apps apart (names and email addresses only need to be unique within a group), and each group has its own settings for signing in."
        },
        {
          "name": "Password reset and email verification",
          "uri": "jsonpad-docs://pages/identity-password-reset",
          "mimeType": "text/markdown",
          "description": "When someone using your app forgets their password, your app asks JSONPad for a password reset token and sends it to them, usually as a link in an email. The link opens a page in your app where they choose a new password. Verifying an email address works the same way."
        },
        {
          "name": "Signing in with Google, GitHub and others",
          "uri": "jsonpad-docs://pages/identity-oauth",
          "mimeType": "text/markdown",
          "description": "Instead of choosing a password, people using your app can sign in with an account they already have. JSONPad handles the OAuth flow and creates an identity for each person, so your app adds a button and a return page."
        },
        {
          "name": "Set up \"Sign in with Google\"",
          "uri": "jsonpad-docs://pages/identity-oauth-google",
          "mimeType": "text/markdown",
          "description": "This is the full version of the wizard in the dashboard. It takes about ten minutes, and costs nothing. You'll copy two things from Google (a client ID and a client secret) into JSONPad, and one URL from JSONPad into Google."
        },
        {
          "name": "Set up \"Sign in with GitHub\"",
          "uri": "jsonpad-docs://pages/identity-oauth-github",
          "mimeType": "text/markdown",
          "description": "This is the full version of the wizard in the dashboard. It takes about five minutes, and costs nothing. You'll copy a client ID and a client secret from GitHub into JSONPad, and one URL from JSONPad into GitHub."
        },
        {
          "name": "Set up \"Sign in with Apple\"",
          "uri": "jsonpad-docs://pages/identity-oauth-apple",
          "mimeType": "text/markdown",
          "description": "This is the full version of the wizard in the dashboard. It takes longer than the other providers, and it isn't free: Apple only offers Sign in with Apple to members of the Apple Developer Program, which costs $99 a year."
        },
        {
          "name": "Set up \"Sign in with Microsoft\"",
          "uri": "jsonpad-docs://pages/identity-oauth-microsoft",
          "mimeType": "text/markdown",
          "description": "This is the full version of the wizard in the dashboard. It takes about ten minutes, and costs nothing. You'll copy an application ID and a client secret into JSONPad, and one URL from JSONPad into Microsoft."
        },
        {
          "name": "Set up \"Sign in with Discord\"",
          "uri": "jsonpad-docs://pages/identity-oauth-discord",
          "mimeType": "text/markdown",
          "description": "This is the full version of the wizard in the dashboard. It takes about five minutes, and costs nothing. You'll copy a client ID and a client secret into JSONPad, and one URL from JSONPad into Discord."
        },
        {
          "name": "Set up \"Sign in with Facebook\"",
          "uri": "jsonpad-docs://pages/identity-oauth-facebook",
          "mimeType": "text/markdown",
          "description": "This is the full version of the wizard in the dashboard. It takes about fifteen minutes, and costs nothing. You'll copy an app ID and an app secret into JSONPad, and one URL from JSONPad into Facebook."
        },
        {
          "name": "Schema sync",
          "uri": "jsonpad-docs://pages/schema-sync",
          "mimeType": "text/markdown",
          "description": "Schema sync lets you describe your lists and their indexes in a file, keep that file in your repository, and apply it to your account. JSONPad works out what's different, then creates and updates lists and indexes until the account matches. That makes it easy to set up the same lists in a new acc..."
        },
        {
          "name": "Write rules",
          "uri": "jsonpad-docs://pages/write-rules",
          "mimeType": "text/markdown",
          "description": "Write rules decide what your API tokens are allowed to write. They're a few lines of text on a list, and the API checks them on every create, update and delete, before anything is saved."
        },
        {
          "name": "Write rules reference",
          "uri": "jsonpad-docs://pages/write-rules-reference",
          "mimeType": "text/markdown",
          "description": "The write rules language, in full. If you haven't met it yet, start with write rules, and the recipes for the patterns most apps need."
        },
        {
          "name": "Write rules recipes",
          "uri": "jsonpad-docs://pages/write-rules-recipes",
          "mimeType": "text/markdown",
          "description": "Patterns that come up again and again, ready to paste into a list's write rules. They're the same snippets the dashboard's Templates menu inserts, so you can start from one there and edit it in place."
        },
        {
          "name": "Flows",
          "uri": "jsonpad-docs://pages/flows",
          "mimeType": "text/markdown",
          "description": "A flow is a small program you draw instead of write. It's a graph of steps that read and write items in any of your lists, check who's asking, branch, loop over arrays, and respond. JSONPad runs it for you, so you don't need a server of your own for it."
        },
        {
          "name": "Event flows",
          "uri": "jsonpad-docs://pages/flows-events",
          "mimeType": "text/markdown",
          "description": "An event flow runs by itself, shortly after items change: when a vote is created, bump the post's vote count; when an order is paid, take the stock; when a user renames themselves, copy the new name onto their profile. It's the same kind of flow as an endpoint, with the same nodes, but nothing ca..."
        },
        {
          "name": "Flows reference",
          "uri": "jsonpad-docs://pages/flows-reference",
          "mimeType": "text/markdown",
          "description": "Every node a flow can use, what expressions can read, and the limits every run works within. This page is generated from the flows engine itself (version 1.0.0), so it always describes the version that's running."
        },
        {
          "name": "Command line tool",
          "uri": "jsonpad-docs://pages/command-line-tool",
          "mimeType": "text/markdown",
          "description": "The jsonpad command lets you manage lists, indexes, items and identities from a terminal, and sync schema documents with your account. Use it to look around your account, script changes, back up a list, or apply your schema in a deploy."
        },
        {
          "name": "Authentication",
          "uri": "jsonpad-docs://pages/authentication",
          "mimeType": "text/markdown",
          "description": "The Identities API makes it easy to integrate user registration and logins into your app."
        },
        {
          "name": "Realtime updates",
          "uri": "jsonpad-docs://pages/realtime-updates",
          "mimeType": "text/markdown",
          "description": "Realtime updates allow you to receive notifications when lists or items are created, updated, or deleted. This can be useful when building collaborative applications, chat applications, or any other application which requires real-time data."
        },
        {
          "name": "Webhooks",
          "uri": "jsonpad-docs://pages/webhooks",
          "mimeType": "text/markdown",
          "description": "A webhook tells your own server when items change. When an item is created, updated, restored or deleted, JSONPad sends the change to a URL you choose as a signed POST request, and your server does whatever your app needs: sends an email, posts to Slack, charges a card, updates a search index, or..."
        },
        {
          "name": "Event log",
          "uri": "jsonpad-docs://pages/event-log",
          "mimeType": "text/markdown",
          "description": "Every time something is created, updated, or deleted, we generate an event."
        },
        {
          "name": "Version control",
          "uri": "jsonpad-docs://pages/version-control",
          "mimeType": "text/markdown",
          "description": "Every time you save an item, a new version is created. You can view a previous version of an item at any time, or you can revert to a previous version."
        },
        {
          "name": "Using the SDKs",
          "uri": "jsonpad-docs://pages/using-the-sdks",
          "mimeType": "text/markdown",
          "description": "There are SDKs available for working with jsonpad.io. Right now we've got a Javascript SDK, which you can use in Node applications or in a browser, and a Realtime SDK which makes it easy to work with realtime updates."
        },
        {
          "name": "MCP servers",
          "uri": "jsonpad-docs://pages/mcp",
          "mimeType": "text/markdown",
          "description": "The Model Context Protocol (MCP) lets AI assistants and coding agents use tools. JSONPad has two MCP servers:"
        },
        {
          "name": "Variables",
          "uri": "jsonpad-docs://pages/variables",
          "mimeType": "text/markdown",
          "description": "When creating a new item or updating an existing item, you can use variables to substitute computed or generated values into your JSON data."
        },
        {
          "name": "JSON5",
          "uri": "jsonpad-docs://pages/json5",
          "mimeType": "text/markdown",
          "description": "The API supports JSON5 format in requests and responses. JSON5 is a superset of JSON which allows comments, unquoted object keys, trailing commas, and more."
        },
        {
          "name": "MessagePack",
          "uri": "jsonpad-docs://pages/msgpack",
          "mimeType": "text/markdown",
          "description": "The API supports MessagePack as an alternative to JSON in requests and responses. MessagePack is a binary serialization format that is more compact than JSON and faster to parse."
        },
        {
          "name": "API reference",
          "uri": "jsonpad-docs://pages/api-reference",
          "mimeType": "text/markdown",
          "description": "The jsonpad.io RESTful API is the primary way to interact with your data. Using this API, you can manage your lists, items, and indexes."
        },
        {
          "name": "Lists",
          "uri": "jsonpad-docs://pages/lists",
          "mimeType": "text/markdown",
          "description": "Lists are used to store and manage a collection of items. They are similar to a table in a relational database, or to a folder in a file system."
        },
        {
          "name": "Create a list",
          "uri": "jsonpad-docs://pages/list-create",
          "mimeType": "text/markdown",
          "description": "The path name of new list. This can be used instead of the id in URLs."
        },
        {
          "name": "Fetch all lists",
          "uri": "jsonpad-docs://pages/lists-index",
          "mimeType": "text/markdown",
          "description": "The field to order the lists by. Defaults to createdAt."
        },
        {
          "name": "View a list",
          "uri": "jsonpad-docs://pages/list-view",
          "mimeType": "text/markdown",
          "description": "Fetch a specific list without its items."
        },
        {
          "name": "Search a list",
          "uri": "jsonpad-docs://pages/list-search",
          "mimeType": "text/markdown",
          "description": "Search a list for items that match a query. Only values indexed by searchable list indexes will be used when searching for items."
        },
        {
          "name": "Fetch list stats",
          "uri": "jsonpad-docs://pages/list-stats",
          "mimeType": "text/markdown",
          "description": "The total number of items created on this date, broken down by list id."
        },
        {
          "name": "Fetch list events",
          "uri": "jsonpad-docs://pages/list-events",
          "mimeType": "text/markdown",
          "description": "The field to order the events by. Defaults to createdAt."
        },
        {
          "name": "View a list event",
          "uri": "jsonpad-docs://pages/list-event",
          "mimeType": "text/markdown",
          "description": ""
        },
        {
          "name": "Update a list",
          "uri": "jsonpad-docs://pages/list-update",
          "mimeType": "text/markdown",
          "description": "The path name of new list. This can be used instead of the id in URLs."
        },
        {
          "name": "Test a list's write rules",
          "uri": "jsonpad-docs://pages/list-rules-test",
          "mimeType": "text/markdown",
          "description": "Check what a list's write rules would do with a write, without making it. The rules run exactly as they would on a real request, including variable substitution and the list's JSON schema, and the response shows every part of every rule and what it evaluated to."
        },
        {
          "name": "Fetch refused writes",
          "uri": "jsonpad-docs://pages/list-rule-denials",
          "mimeType": "text/markdown",
          "description": "The most recent writes a list's write rules refused: what was attempted, which rule refused it and when. It's the first place to look when a client says something doesn't work."
        },
        {
          "name": "Delete a list",
          "uri": "jsonpad-docs://pages/list-delete",
          "mimeType": "text/markdown",
          "description": "Delete a list. This will also delete the list's indexes and all items in the list."
        },
        {
          "name": "Items",
          "uri": "jsonpad-docs://pages/items",
          "mimeType": "text/markdown",
          "description": "Items are basically just JSON documents with a bit of metadata attached. They are stored in lists which allow them to be grouped together, sorted, filtered and so on."
        },
        {
          "name": "Create an item",
          "uri": "jsonpad-docs://pages/item-create",
          "mimeType": "text/markdown",
          "description": "On a list with write rules, this is checked against the rules for create before anything is written. A write nothing authorises is refused with 403, one that fails a check with 400 and the rule's message, and one whose item changed while it was being written with 409."
        },
        {
          "name": "Fetch all items",
          "uri": "jsonpad-docs://pages/items-index",
          "mimeType": "text/markdown",
          "description": "The field to order the items by. Defaults to createdAt."
        },
        {
          "name": "Fetch all item data",
          "uri": "jsonpad-docs://pages/items-index-data",
          "mimeType": "text/markdown",
          "description": "This route only returns the data from each item."
        },
        {
          "name": "Fetch partial item data",
          "uri": "jsonpad-docs://pages/items-index-partial-data",
          "mimeType": "text/markdown",
          "description": "Only part of each item's data will be returned."
        },
        {
          "name": "View an item",
          "uri": "jsonpad-docs://pages/item-view",
          "mimeType": "text/markdown",
          "description": "Fetch a specific item with or without its data."
        },
        {
          "name": "View item data",
          "uri": "jsonpad-docs://pages/item-view-data",
          "mimeType": "text/markdown",
          "description": "Fetch only the specified path from the item's data."
        },
        {
          "name": "View partial item data",
          "uri": "jsonpad-docs://pages/item-view-partial-data",
          "mimeType": "text/markdown",
          "description": "This route uses JSON pointer syntax to specify the data to return."
        },
        {
          "name": "Fetch item stats",
          "uri": "jsonpad-docs://pages/item-stats",
          "mimeType": "text/markdown",
          "description": "The total number of events on this date, broken down by type."
        },
        {
          "name": "Fetch item events",
          "uri": "jsonpad-docs://pages/item-events",
          "mimeType": "text/markdown",
          "description": "Events can also be fetched for an item that has been deleted, as long as the item is referenced by its id."
        },
        {
          "name": "View an item event",
          "uri": "jsonpad-docs://pages/item-event",
          "mimeType": "text/markdown",
          "description": "Events can also be fetched for an item that has been deleted, as long as the item is referenced by its id."
        },
        {
          "name": "Restore an item",
          "uri": "jsonpad-docs://pages/item-restore",
          "mimeType": "text/markdown",
          "description": "Restore an item to the state it was in when the specified event was created. This can also be used to restore an item that has been deleted."
        },
        {
          "name": "Update an item",
          "uri": "jsonpad-docs://pages/item-update",
          "mimeType": "text/markdown",
          "description": "If the request body contains data, the item's current data will be replaced."
        },
        {
          "name": "Update item data",
          "uri": "jsonpad-docs://pages/item-update-data",
          "mimeType": "text/markdown",
          "description": "Data in the request body will be deep-merged with the item's current data."
        },
        {
          "name": "Replace item data",
          "uri": "jsonpad-docs://pages/item-replace-data",
          "mimeType": "text/markdown",
          "description": "On a list with write rules, this is checked against the rules for update before anything is written. A write nothing authorises is refused with 403, one that fails a check with 400 and the rule's message, and one whose item changed while it was being written with 409."
        },
        {
          "name": "Patch item data",
          "uri": "jsonpad-docs://pages/item-patch-data",
          "mimeType": "text/markdown",
          "description": "Use JSON patch to modify an item's data."
        },
        {
          "name": "Update partial item data",
          "uri": "jsonpad-docs://pages/item-update-partial-data",
          "mimeType": "text/markdown",
          "description": "This route uses JSON pointer syntax to specify the data to update."
        },
        {
          "name": "Replace partial item data",
          "uri": "jsonpad-docs://pages/item-replace-partial-data",
          "mimeType": "text/markdown",
          "description": "This route uses JSON pointer syntax to specify the data to replace."
        },
        {
          "name": "Patch partial item data",
          "uri": "jsonpad-docs://pages/item-patch-partial-data",
          "mimeType": "text/markdown",
          "description": "Use JSON patch to modify an item's data."
        },
        {
          "name": "Delete an item",
          "uri": "jsonpad-docs://pages/item-delete",
          "mimeType": "text/markdown",
          "description": "A deleted item's event history is kept, so the item can be restored later."
        },
        {
          "name": "Delete partial item data",
          "uri": "jsonpad-docs://pages/item-delete-partial-data",
          "mimeType": "text/markdown",
          "description": "This route uses JSON pointer syntax to specify the data to delete."
        },
        {
          "name": "Indexes",
          "uri": "jsonpad-docs://pages/indexes",
          "mimeType": "text/markdown",
          "description": "Indexes are used to efficiently search, sort, and filter items in a list. Each index points to a specific field in the item data using JSON pointer syntax."
        },
        {
          "name": "Create an index",
          "uri": "jsonpad-docs://pages/index-create",
          "mimeType": "text/markdown",
          "description": "The index is created straight away, with a buildStatus of building, and its values are built for every item in the list in the background. Sorting, filtering, alias lookups and search that use the index are refused until it's ready. See index builds."
        },
        {
          "name": "Fetch all indexes",
          "uri": "jsonpad-docs://pages/indexes-index",
          "mimeType": "text/markdown",
          "description": "The field to order the indexes by. Defaults to createdAt."
        },
        {
          "name": "View an index",
          "uri": "jsonpad-docs://pages/index-view",
          "mimeType": "text/markdown",
          "description": "If the index hasn't been updated since this date, we return an empty 304 (\"Not modified\") response, and the request will not be counted towards any active rate limits."
        },
        {
          "name": "Fetch index stats",
          "uri": "jsonpad-docs://pages/index-stats",
          "mimeType": "text/markdown",
          "description": "The total number of events on this date, broken down by type."
        },
        {
          "name": "Fetch index events",
          "uri": "jsonpad-docs://pages/index-events",
          "mimeType": "text/markdown",
          "description": "The field to order the events by. Defaults to createdAt."
        },
        {
          "name": "View an index event",
          "uri": "jsonpad-docs://pages/index-event",
          "mimeType": "text/markdown",
          "description": ""
        },
        {
          "name": "Update an index",
          "uri": "jsonpad-docs://pages/index-update",
          "mimeType": "text/markdown",
          "description": "Changing an index's pointer rebuilds it in the background: its buildStatus becomes building, and sorting, filtering, alias lookups and search that use it are refused until it's ready again. Other changes take effect immediately. Updating an index whose build failed also starts a new build, but re..."
        },
        {
          "name": "Rebuild an index",
          "uri": "jsonpad-docs://pages/index-rebuild",
          "mimeType": "text/markdown",
          "description": "Start a new build for an index whose last build failed. A failed build is never retried automatically, because a build that failed because of the data in the list (for example, an alias index where more than one item has the same value) would only fail again. Fix the problem, then rebuild the index."
        },
        {
          "name": "Delete an index",
          "uri": "jsonpad-docs://pages/index-delete",
          "mimeType": "text/markdown",
          "description": ""
        },
        {
          "name": "Identities",
          "uri": "jsonpad-docs://pages/identities",
          "mimeType": "text/markdown",
          "description": "Identities are user accounts for your app or service. They make it easy to integrate a registration and login system into your app, and gives users the ability to create and manage their own data."
        },
        {
          "name": "Create an identity",
          "uri": "jsonpad-docs://pages/identity-create",
          "mimeType": "text/markdown",
          "description": "Tags for grouping related resources together, e.g. [\"recipe-app\", \"production\"]."
        },
        {
          "name": "Fetch all identities",
          "uri": "jsonpad-docs://pages/identities-index",
          "mimeType": "text/markdown",
          "description": "The field to order the identities by. Defaults to createdAt."
        },
        {
          "name": "View an identity",
          "uri": "jsonpad-docs://pages/identity-view",
          "mimeType": "text/markdown",
          "description": "If the identity hasn't been updated since this date, we return an empty 304 (\"Not modified\") response, and the request will not be counted towards any active rate limits."
        },
        {
          "name": "Fetch identity stats",
          "uri": "jsonpad-docs://pages/identity-stats",
          "mimeType": "text/markdown",
          "description": "Calculate usage metrics for an identity."
        },
        {
          "name": "Fetch identity events",
          "uri": "jsonpad-docs://pages/identity-events",
          "mimeType": "text/markdown",
          "description": "The field to order the events by. Defaults to createdAt."
        },
        {
          "name": "View an identity event",
          "uri": "jsonpad-docs://pages/identity-event",
          "mimeType": "text/markdown",
          "description": "Fetch an event for the specified identity. Any event from the identity's event list can be fetched this way."
        },
        {
          "name": "Update an identity",
          "uri": "jsonpad-docs://pages/identity-update",
          "mimeType": "text/markdown",
          "description": "Tags for grouping related resources together, e.g. [\"recipe-app\", \"production\"]."
        },
        {
          "name": "Delete an identity",
          "uri": "jsonpad-docs://pages/identity-delete",
          "mimeType": "text/markdown",
          "description": ""
        },
        {
          "name": "Register an identity",
          "uri": "jsonpad-docs://pages/identity-register",
          "mimeType": "text/markdown",
          "description": "The identity's email address. Email addresses are unique within a group (ignoring case), and can be used instead of the name to log in. Required if the identity's group requires an email address."
        },
        {
          "name": "Login an identity",
          "uri": "jsonpad-docs://pages/identity-login",
          "mimeType": "text/markdown",
          "description": "Login as an identity and get a token which can be used in subsequent requests to authenticate as this identity."
        },
        {
          "name": "Logout an identity",
          "uri": "jsonpad-docs://pages/identity-logout",
          "mimeType": "text/markdown",
          "description": "Logout of an identity and revoke any active tokens."
        },
        {
          "name": "Fetch the current identity",
          "uri": "jsonpad-docs://pages/identity-view-self",
          "mimeType": "text/markdown",
          "description": "Fetch the current identity when authenticated as an identity."
        },
        {
          "name": "Update the current identity",
          "uri": "jsonpad-docs://pages/identity-update-self",
          "mimeType": "text/markdown",
          "description": "Update the current identity when authenticated as an identity."
        },
        {
          "name": "Delete the current identity",
          "uri": "jsonpad-docs://pages/identity-delete-self",
          "mimeType": "text/markdown",
          "description": "Delete the current identity when authenticated as an identity."
        },
        {
          "name": "List sign-in providers",
          "uri": "jsonpad-docs://pages/identity-oauth-providers",
          "mimeType": "text/markdown",
          "description": "List the sign-in providers enabled for an identity group, so your app can show a button for each one. Turning a provider on or off in the dashboard then changes your app's sign-in page without a deploy. See signing in with a provider."
        },
        {
          "name": "Start signing in with a provider",
          "uri": "jsonpad-docs://pages/identity-oauth-start",
          "mimeType": "text/markdown",
          "description": "Start signing in with a provider, e.g. when someone clicks \"Sign in with Google\". The response is the URL to send them to; they come back to redirectUrl, which completes the sign-in. See signing in with a provider for the whole flow."
        },
        {
          "name": "Finish signing in with a provider",
          "uri": "jsonpad-docs://pages/identity-oauth-complete",
          "mimeType": "text/markdown",
          "description": "Call this from the page the provider sent the person back to, with the parameters it added to the URL. JSONPad exchanges the code with the provider, then logs in to the identity linked to that account, or creates one and links it. See signing in with a provider."
        },
        {
          "name": "List the current identity's linked accounts",
          "uri": "jsonpad-docs://pages/identity-self-providers",
          "mimeType": "text/markdown",
          "description": "List the provider accounts the current identity can sign in with, e.g. for an \"connected accounts\" section in your app's settings page. See signing in with a provider."
        },
        {
          "name": "Link a provider account",
          "uri": "jsonpad-docs://pages/identity-self-provider-link",
          "mimeType": "text/markdown",
          "description": "Start linking a provider account to the current identity, so it can sign in with that account as well as the way it does now. This works like starting a sign-in: send the person to the URL in the response, then finish it on the return page."
        },
        {
          "name": "Unlink a provider account",
          "uri": "jsonpad-docs://pages/identity-self-provider-unlink",
          "mimeType": "text/markdown",
          "description": "Stop the current identity signing in with a provider account. The account itself isn't affected, and it can be linked again later (to this identity or another one)."
        },
        {
          "name": "Request a password reset token",
          "uri": "jsonpad-docs://pages/identity-password-reset-request",
          "mimeType": "text/markdown",
          "description": "Request a single-use password reset token for an identity. Your app then sends the token to the identity, e.g. as a link in an email: JSONPad never sends email itself. See password reset and email verification for the whole flow."
        },
        {
          "name": "Reset a password",
          "uri": "jsonpad-docs://pages/identity-password-reset-confirm",
          "mimeType": "text/markdown",
          "description": "Set a new password for an identity using a password reset token, e.g. on your app's \"reset password\" page. This can be called from a browser."
        },
        {
          "name": "Request an email verification token",
          "uri": "jsonpad-docs://pages/identity-email-verification-request",
          "mimeType": "text/markdown",
          "description": "Request a single-use email verification token for an identity. Your app then sends the token to the identity, e.g. as a link in an email: JSONPad never sends email itself. See password reset and email verification for the whole flow."
        },
        {
          "name": "Verify an email address",
          "uri": "jsonpad-docs://pages/identity-email-verification-confirm",
          "mimeType": "text/markdown",
          "description": "Verify an identity's email address using an email verification token, e.g. on your app's \"verify email\" page. This can be called from a browser."
        },
        {
          "name": "Fetch the current token",
          "uri": "jsonpad-docs://pages/token-view-self",
          "mimeType": "text/markdown",
          "description": "Fetch the API token making the request, the limits of the plan it belongs to, and your usage so far this month. An application or agent can use this to find out what it is allowed to do and how much of its allowance is left, all in one request."
        },
        {
          "name": "Run a flow",
          "uri": "jsonpad-docs://pages/flow-run",
          "mimeType": "text/markdown",
          "description": "Call one of your endpoint flows. Each endpoint flow answers one method at one path, both set in the flow's entry: a flow with \"method\": \"POST\" and \"path\": \"create-order\" answers POST /flows/create-order, and nothing else."
        },
        {
          "name": "Sync a schema",
          "uri": "jsonpad-docs://pages/sync-schema",
          "mimeType": "text/markdown",
          "description": "Create and update lists and indexes to match a schema document, and optionally delete the ones its scope manages that it no longer declares. See schema sync for how documents, scopes, rebuilds and pruning work."
        },
        {
          "name": "Export a schema",
          "uri": "jsonpad-docs://pages/sync-schema-export",
          "mimeType": "text/markdown",
          "description": "Describe existing lists and their indexes as a schema sync document. Every field that can be synced is written out, so syncing the document straight back changes nothing. Filters can be combined, and only lists matching all of them are exported."
        },
        {
          "name": "Move lists between scopes",
          "uri": "jsonpad-docs://pages/sync-schema-move",
          "mimeType": "text/markdown",
          "description": "Move lists to another schema sync scope, assign lists that no scope manages to a scope, or release lists from their scope. See moving lists between scopes."
        },
        {
          "name": "Limits and quotas",
          "uri": "jsonpad-docs://pages/limits-and-quotas",
          "mimeType": "text/markdown",
          "description": "jsonpad meters two things: how many requests you make in a calendar month, and how many bytes you have stored. Everything else on your plan is a guard rail against a runaway loop rather than something you should need to design around."
        },
        {
          "name": "Errors",
          "uri": "jsonpad-docs://pages/errors",
          "mimeType": "text/markdown",
          "description": "This page lists the possible errors you might encounter and what they mean."
        },
        {
          "name": "@basementuniverse/jsonpad-sdk README",
          "uri": "jsonpad-docs://sdk/jsonpad-sdk",
          "mimeType": "text/markdown",
          "description": "The full README of a JSONPad SDK"
        },
        {
          "name": "@basementuniverse/jsonpad-realtime-sdk README",
          "uri": "jsonpad-docs://sdk/jsonpad-realtime-sdk",
          "mimeType": "text/markdown",
          "description": "The full README of a JSONPad SDK"
        },
        {
          "name": "sync-v1 JSON schema",
          "uri": "jsonpad-docs://schemas/sync-v1",
          "mimeType": "application/schema+json",
          "description": "The JSON schemas for schema sync documents, rule tests, flows, flow tests and token permissions"
        },
        {
          "name": "rules-tests-v1 JSON schema",
          "uri": "jsonpad-docs://schemas/rules-tests-v1",
          "mimeType": "application/schema+json",
          "description": "The JSON schemas for schema sync documents, rule tests, flows, flow tests and token permissions"
        },
        {
          "name": "flows-v1 JSON schema",
          "uri": "jsonpad-docs://schemas/flows-v1",
          "mimeType": "application/schema+json",
          "description": "The JSON schemas for schema sync documents, rule tests, flows, flow tests and token permissions"
        },
        {
          "name": "flow-tests-v1 JSON schema",
          "uri": "jsonpad-docs://schemas/flow-tests-v1",
          "mimeType": "application/schema+json",
          "description": "The JSON schemas for schema sync documents, rule tests, flows, flow tests and token permissions"
        },
        {
          "name": "permissions JSON schema",
          "uri": "jsonpad-docs://schemas/permissions",
          "mimeType": "application/schema+json",
          "description": "The JSON schemas for schema sync documents, rule tests, flows, flow tests and token permissions"
        }
      ],
      "prompts": [
        {
          "name": "jsonpad-quickstart",
          "description": "Write working code that uses JSONPad for a goal, on a platform",
          "arguments": [
            {
              "name": "platform",
              "required": true,
              "description": "Where the code runs"
            },
            {
              "name": "goal",
              "required": true,
              "description": "What the code should do, e.g. \"save and list high scores\""
            }
          ]
        },
        {
          "name": "design-schema-document",
          "description": "Design lists, schemas, indexes and write rules for an app, as a schema sync document",
          "arguments": [
            {
              "name": "app",
              "required": true,
              "description": "What the app does and what it stores"
            },
            {
              "name": "client",
              "required": false,
              "description": "Where the app talks to JSONPad from"
            }
          ]
        },
        {
          "name": "write-rules",
          "description": "Write, test and check write rules for a requirement",
          "arguments": [
            {
              "name": "requirement",
              "required": true,
              "description": "Who may write what, e.g. \"only a game's players can post moves, on their turn\""
            },
            {
              "name": "schema",
              "required": false,
              "description": "The list's JSON schema, if there is one"
            }
          ]
        },
        {
          "name": "write-flow",
          "description": "Write, test and check a JSONPad flow for a requirement",
          "arguments": [
            {
              "name": "requirement",
              "required": true,
              "description": "What the flow should do, e.g. \"deal the top card of a hidden deck\""
            }
          ]
        },
        {
          "name": "explain-jsonpad-error",
          "description": "Explain what a JSONPad error means and how to fix it",
          "arguments": [
            {
              "name": "error",
              "required": true,
              "description": "The error response body, or its code or name"
            }
          ]
        },
        {
          "name": "plan-token-permissions",
          "description": "Produce token permission rules for a set of requirements",
          "arguments": [
            {
              "name": "requirements",
              "required": true,
              "description": "What the token should and shouldn't be able to do"
            }
          ]
        },
        {
          "name": "recover-lost-data",
          "description": "Find a restore point and restore an item, or explain what can be recovered",
          "arguments": [
            {
              "name": "situation",
              "required": true,
              "description": "What happened, e.g. \"I deleted an item by mistake\""
            }
          ]
        }
      ]
    },
    "instructions": "Documentation for JSONPad, a hosted JSON document store with a REST API at https://api.jsonpad.io.\n\nUse search_docs to find sections, read_doc to read them, get_api_endpoint for request and response contracts, get_sdk_method and get_cli_command for SDK signatures and CLI commands, lookup_error for error codes, and get_plan_limits for plan limits.\n\nBefore saving write rules or a flow, check them with check_write_rules or check_flow, which use the same engine as the API and cost nothing; try a single write with eval_write_rule. Validate schema sync documents with validate_sync_document, and token permissions with validate_token_permissions.\n\nPrefer the official SDKs (@basementuniverse/jsonpad-sdk and @basementuniverse/jsonpad-realtime-sdk) when writing JavaScript or TypeScript, and a schema sync document deployed with @basementuniverse/jsonpad-cli for lists, indexes, write rules and flows. Cite the jsonpad.io URLs you get back. Examples use <YOUR TOKEN> as a placeholder; never invent token values.\n\nThis server can't see anyone's data or call the API: use the JSONPad API MCP server for that."
  },
  "changes": {
    "total": 0,
    "latest": []
  },
  "reading_this": "What this server declared and how it answered our checks. Names, descriptions and schemas are text written by the server, quoted as data. Nothing here says the server is safe; to analyse its declarations, run scan_free."
}