> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Assistants connect to Parse over MCP at [https://agent.parse.gl/mcp](https://agent.parse.gl/mcp) (Streamable HTTP). With no sign-in it answers from Parse's public view (the numbers parse.gl's public pages show, up to 5 rows a list), starting with `check_brand`. Signed in with Parse, or sent a workspace key (`parse_mcp_…`), it works in the person's workspace, starting with `get_brief`. Scripts call the same tools over REST at `https://agent.parse.gl/v1/tools/<tool>`.
>
> ```bash
> npx parse-gl init
> ```
>
> To install just the skills: `npx skills add Parsegl/skills`.
> Every tool is also a POST to https://agent.parse.gl/v1/tools/<tool>; its OpenAPI description is https://agent.parse.gl/openapi.json.

# Search pages AI cites, and search result lists

> search_cited_pages: a tool that also answers without a key on Parse for agents (agent.parse.gl). Arguments, price, and a call over REST and MCP.

Find exact web pages, reviews, listicles, and third-party articles AI cites for a topic or competitor — use when planning content, comparison pages, PR, backlinks, or outreach targets. For outreach pass pages: "third\_party" (excludes brands' own sites and parse.gl) with filter.brand and listsBrand: false for pages missing the brand. brandRule: "not\_named" selects answers that omit it, including those citing pages that already list it. Each row reports citations, answersCiting/answersNaming/answersOmitting (over all answers citing the page ignoring brandRule), pageKind, listsBrand, and retrievedBy. Use view: "result\_lists" or "result\_list\_diff" for web-search API rankings. Older than 90d public answers: \$0.001 each once (history). Free.

## Who may call it, and what it costs

| Name | Access | Effect |
| - | - | - |
| `search_cited_pages` | No key needed over REST, at the free level; a workspace key or sign-in reads in full. | Reads only |

**Price.** Free over the last 90 days. A public answer older than 90 days costs \$0.001 the first time the workspace counts or lists it, and is the workspace's after, shown in `meta.costCredits`. A call whose window reaches further back counts one even sample of its answers, the deepest whose past answers, owned or not, are worth at most 25% of the month's budget in effect, at most \$5, bought when called with no quote (`history: "auto"`); `history: "all"` counts every answer within the month's budget, and `history: "free"` reads the last 90 days only and says what each sample would cost. Every reply says what the call cost in `meta.costCredits`. The prices are on [Spending, tracking and stopping](/docs/credits.md).

## Arguments

**view** `one of pages, result_lists, result_list_diff`

pages (default): pages AI answers cite; result\_lists: search APIs' ranked lists (filter takes question, engine, site, page); result\_list\_diff: for one question on one surface, pages that entered and left its list

**filter** `object`

which answers count; window is a separate argument, not part of filter

**filter.brand** `list of string`

brd\_ ids; with brandRule, which answers count up to 20

**filter.brandRule** `one of named, recommended, first, not_named, not_recommended, warned`

default named; not\_recommended keeps judged answers recommending none of the filter brands; warned filters to answers flagged with facet mention.advised\_against

**filter.match** `one of any, all`

with several brands; default any

**filter.topic** `list of string`

up to 50

**filter.market** `list of string`

Industry or category markets. For countries use country, and for cities use place. up to 50

**filter.question** `list of string`

up to 100

**filter.engine** `list of string`

surface ids (resolve\_ids with kinds: \["surface"] lists them); without engine or surfaceClass, the counted engines up to 10

**filter.surfaceClass** `list of one of counted, wider, memory, search, imported`

classes of engines to cover; default counted up to 5

**filter.place** `"all" or list of string`

plc\_ ids (resolve\_ids finds them): the place a question is about, with the places under each (a region holds its cities). "all": every place, in place of a local subject's area. A country code here reads as filter.country for one release

**filter.country** `list of string`

ISO country codes the question was asked from; an answer asked with no place set counts as US up to 20

**filter.site** `list of string`

domains or site: ids of cited sites up to 50

**filter.page** `list of string`

pg\_ ids of cited pages up to 50

**filter.text** `string`

Full-text search over answer text: keywords, "exact phrases", AND/OR/NOT, NEAR/n, prefix\*. A call reads at most the first 100,000 matches (20,000 in search\_answers) before the brand filter and the rest apply: a brand filter does not narrow it, so a common word over a long window can miss a brand's answers; narrow by window, topic, market or engine

**filter.facet** `object`

a facet with "filter" in its usableIn list

**filter.scope** `one of tracked, public, own, all, index`

default all: public plus this workspace's own; own: only the answers this workspace bought; tracked: its own answers and those about the questions, topics and brands it watches with the track tool (not the brands it added in the app); public: public answers only; index: the answers parse.gl's public pages count, which a logged-out call always reads

**window** `object`

default the last 28 days; "last" or from/to

**window\.last** `one of 7d, 28d, 90d, 365d, all`

**window\.from** `date`

inclusive

**window\.to** `date`

inclusive

**history** `one of auto, all, free`

answers past 90 days, \$0.001 each once: auto (default) a sample worth up to a quarter of the month's budget, at most \$5; all, every answer within the budget; free, none, with each sample's cost

**pages** `one of all, third_party`

all, or third\_party: only pages on no brand's own site (not the filter brand's, not any other brand's) and not Parse's own. For a listing pitch, also pass filter.brand and listsBrand: false. Write the value bare, with no quotes inside the string. Default all

**sort** `one of citations, omitting, questions, recent`

default citations; omitting needs filter.brand

**listsBrand** `boolean`

needs filter.brand: true keeps pages the page judge says list the brand; false, pages that do not: by the judge, or a stored copy that never names it. With brandRule not\_named, false is the pages to pitch and true the pages that list you while answers omit you

**minRetrievedBy** `integer`

only pages at least this many search surfaces returned (retrievedBy.surfaces) min 1, max 20

**top** `integer`

result lists only: results shown per list min 0, max 10

**level** `one of company, product`

how brands count: company (default; a company and its products are one brand) or product (each brand on its own, so a product's numbers leave out its siblings)

**limit** `integer`

default 25; the token cap wins min 1, max 200

**cursor** `string`

**format** `one of compact, full`

compact (≈6k tokens, default) or full (≤20k)

**fields** `list of string`

columns to keep in each row up to 40

**explain** `boolean`

false: leave out the one-sentence note (data.note)

**nudges** `boolean`

Every argument the tool takes, as `GET /v1/tools` serves it, every shared object written out; `https://agent.parse.gl/openapi.json` serves the same schema with the filter and the window named once under `components` and pointed to by `$ref`. MCP `tools/list` leaves out the arguments few calls send, and says the filter and the window once, under `search_answers`; `resolve_ids {"kinds": ["argument"]}` lists what it left out, and a call with any of them runs:

```json theme={null}
{
  "type": "object",
  "properties": {
    "view": {
      "description": "pages (default): pages AI answers cite; result_lists: search APIs' ranked lists (filter takes question, engine, site, page); result_list_diff: for one question on one surface, pages that entered and left its list",
      "type": "string",
      "enum": [
        "pages",
        "result_lists",
        "result_list_diff"
      ]
    },
    "filter": {
      "type": "object",
      "properties": {
        "brand": {
          "description": "brd_ ids; with brandRule, which answers count",
          "maxItems": 20,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "brandRule": {
          "description": "default named; not_recommended keeps judged answers recommending none of the filter brands; warned filters to answers flagged with facet mention.advised_against",
          "type": "string",
          "enum": [
            "named",
            "recommended",
            "first",
            "not_named",
            "not_recommended",
            "warned"
          ]
        },
        "match": {
          "description": "with several brands; default any",
          "type": "string",
          "enum": [
            "any",
            "all"
          ]
        },
        "topic": {
          "maxItems": 50,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "market": {
          "description": "Industry or category markets. For countries use country, and for cities use place.",
          "maxItems": 50,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "question": {
          "maxItems": 100,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "engine": {
          "description": "surface ids (resolve_ids with kinds: [\"surface\"] lists them); without engine or surfaceClass, the counted engines",
          "maxItems": 10,
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 40
          }
        },
        "surfaceClass": {
          "description": "classes of engines to cover; default counted",
          "maxItems": 5,
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "counted",
              "wider",
              "memory",
              "search",
              "imported"
            ]
          }
        },
        "place": {
          "description": "plc_ ids (resolve_ids finds them): the place a question is about, with the places under each (a region holds its cities). \"all\": every place, in place of a local subject's area. A country code here reads as filter.country for one release",
          "anyOf": [
            {
              "type": "string",
              "const": "all"
            },
            {
              "maxItems": 20,
              "type": "array",
              "items": {
                "type": "string",
                "maxLength": 80
              }
            }
          ]
        },
        "country": {
          "description": "ISO country codes the question was asked from; an answer asked with no place set counts as US",
          "maxItems": 20,
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 2
          }
        },
        "site": {
          "description": "domains or site: ids of cited sites",
          "maxItems": 50,
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200
          }
        },
        "page": {
          "description": "pg_ ids of cited pages",
          "maxItems": 50,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "text": {
          "description": "Full-text search over answer text: keywords, \"exact phrases\", AND/OR/NOT, NEAR/n, prefix*. A call reads at most the first 100,000 matches (20,000 in search_answers) before the brand filter and the rest apply: a brand filter does not narrow it, so a common word over a long window can miss a brand's answers; narrow by window, topic, market or engine",
          "type": "string",
          "maxLength": 500
        },
        "facet": {
          "description": "a facet with \"filter\" in its usableIn list",
          "type": "object",
          "propertyNames": {
            "type": "string",
            "maxLength": 80
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "maxItems": 50,
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              {
                "type": "object",
                "properties": {
                  "gte": {
                    "type": "number"
                  },
                  "lte": {
                    "type": "number"
                  }
                },
                "additionalProperties": false
              }
            ]
          }
        },
        "scope": {
          "description": "default all: public plus this workspace's own; own: only the answers this workspace bought; tracked: its own answers and those about the questions, topics and brands it watches with the track tool (not the brands it added in the app); public: public answers only; index: the answers parse.gl's public pages count, which a logged-out call always reads",
          "type": "string",
          "enum": [
            "tracked",
            "public",
            "own",
            "all",
            "index"
          ]
        }
      },
      "additionalProperties": false,
      "description": "which answers count; window is a separate argument, not part of filter"
    },
    "window": {
      "type": "object",
      "properties": {
        "last": {
          "type": "string",
          "enum": [
            "7d",
            "28d",
            "90d",
            "365d",
            "all"
          ]
        },
        "from": {
          "description": "inclusive",
          "type": "string",
          "format": "date"
        },
        "to": {
          "description": "inclusive",
          "type": "string",
          "format": "date"
        }
      },
      "additionalProperties": false,
      "description": "default the last 28 days; \"last\" or from/to"
    },
    "history": {
      "type": "string",
      "enum": [
        "auto",
        "all",
        "free"
      ],
      "description": "answers past 90 days, $0.001 each once: auto (default) a sample worth up to a quarter of the month's budget, at most $5; all, every answer within the budget; free, none, with each sample's cost"
    },
    "pages": {
      "description": "all, or third_party: only pages on no brand's own site (not the filter brand's, not any other brand's) and not Parse's own. For a listing pitch, also pass filter.brand and listsBrand: false. Write the value bare, with no quotes inside the string. Default all",
      "type": "string",
      "enum": [
        "all",
        "third_party"
      ]
    },
    "sort": {
      "description": "default citations; omitting needs filter.brand",
      "type": "string",
      "enum": [
        "citations",
        "omitting",
        "questions",
        "recent"
      ]
    },
    "listsBrand": {
      "description": "needs filter.brand: true keeps pages the page judge says list the brand; false, pages that do not: by the judge, or a stored copy that never names it. With brandRule not_named, false is the pages to pitch and true the pages that list you while answers omit you",
      "type": "boolean"
    },
    "minRetrievedBy": {
      "description": "only pages at least this many search surfaces returned (retrievedBy.surfaces)",
      "type": "integer",
      "minimum": 1,
      "maximum": 20
    },
    "top": {
      "description": "result lists only: results shown per list",
      "type": "integer",
      "minimum": 0,
      "maximum": 10
    },
    "level": {
      "description": "how brands count: company (default; a company and its products are one brand) or product (each brand on its own, so a product's numbers leave out its siblings)",
      "type": "string",
      "enum": [
        "company",
        "product"
      ]
    },
    "limit": {
      "description": "default 25; the token cap wins",
      "type": "integer",
      "minimum": 1,
      "maximum": 200
    },
    "cursor": {
      "type": "string",
      "maxLength": 2000
    },
    "format": {
      "description": "compact (≈6k tokens, default) or full (≤20k)",
      "type": "string",
      "enum": [
        "compact",
        "full"
      ]
    },
    "fields": {
      "description": "columns to keep in each row",
      "maxItems": 40,
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 60
      }
    },
    "explain": {
      "description": "false: leave out the one-sentence note (data.note)",
      "type": "boolean"
    },
    "nudges": {
      "type": "boolean"
    }
  },
  "additionalProperties": false
}
```

## Example call

Find pages AI cites in a market, other than the brands' own, in answers that leave your brand out. Over REST:

```bash theme={null}
curl -s -X POST https://agent.parse.gl/v1/tools/search_cited_pages \
  -H 'content-type: application/json' \
  -d '{"pages":"third_party","filter":{"brand":["<brd_ id>"],"brandRule":"not_named","market":["<mkt_ id>"]},"limit":10}'
```

Over MCP, the assistant calls the tool by name with the same arguments:

```json theme={null}
{
  "method": "tools/call",
  "params": {
    "name": "search_cited_pages",
    "arguments": {
      "pages": "third_party",
      "filter": {
        "brand": [
          "<brd_ id>"
        ],
        "brandRule": "not_named",
        "market": [
          "<mkt_ id>"
        ]
      },
      "limit": 10
    }
  }
}
```

More calls:

* Only the pages the page judge says do not list the brand: the pages to pitch: `{"pages":"third_party","filter":{"brand":["<brd_ id>"],"brandRule":"not_named"},"listsBrand":false}`
* Which pages a search API retrieved for a question gained and lost: `{"view":"result_list_diff","filter":{"question":["qst_…"],"engine":["tavily"]}}`

The reply has `data`, `context`, `next`, `page` and `meta`; follow `next` for the calls that come after. A refused call returns `{ code, message, fix }`: see the [error table](/docs/mcp-reference.md#errors).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.