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

> ## Agent Instructions
> Every page is listed in https://docs.keenable.ai/llms.txt. To pick a product for a job, read https://docs.keenable.ai/choose.md
> Setup steps for agents, covering the SDKs, the MCP server and the CLI: https://docs.keenable.ai/skill.md
> Keenable search and fetch work without an API key. To add them to code, use the official SDK for the project's language: https://docs.keenable.ai/sdks.md
> Without a key, call POST https://api.keenable.ai/v1/search/public or GET https://api.keenable.ai/v1/fetch/public with an X-Keenable-Title header that names your app.
> With a key, send it in the X-API-Key header and read it from the KEENABLE_API_KEY environment variable. Never ask a user to paste a key into chat. Every access method: https://docs.keenable.ai/auth.md
> To get an API key without the console, use device login: https://docs.keenable.ai/authentication.md#device-login
> MCP server: https://api.keenable.ai/mcp (no key, or X-API-Key; keyless Codex uses https://api.keenable.ai/mcp-public), or https://api.keenable.ai/mcp-oauth for OAuth sign-in. These docs are an MCP server at https://docs.keenable.ai/mcp and the OpenAPI spec is at https://docs.keenable.ai/api-reference/openapi.json
> Keenable searches and fetches public web pages. If a question needs no web information, skip the call.
> On 402 with an API key (code insufficient_credits), stop and ask a human to add credits; don't retry. On 429, wait the number of seconds in Retry-After, then retry. Before you ship, follow https://docs.keenable.ai/production.md
> Every error, with its cause and fix, is in https://docs.keenable.ai/errors.md and moving from another search API is covered in https://docs.keenable.ai/migrate.md
> Before you compare Keenable with another search API, read https://docs.keenable.ai/guides/evaluate-search-apis.md

# List results

> List a monitor's results with GET /v1/monitors/{id}/results: every result it accepted, newest first, one per story, filtered by importance.

List the monitor's results, every page it accepted, newest first, whether or not a run or webhook delivered it. To read a monitor without a webhook or schedule, poll this endpoint and stop at the first `id` you've already seen.

## When to use it

Use it when you have no public endpoint for a webhook and no schedule, or to look back over results a run or webhook already gave you. Pass `min_importance=4` to keep only the results not to be missed. This request returns them:

```bash theme={"theme":{"light":"github-light-high-contrast","dark":"dark-plus"}}
curl -G "https://api.keenable.ai/v1/monitors/mon_123/results" \
  -H "X-API-Key: $KEENABLE_API_KEY" \
  --data-urlencode "min_importance=4"
```

Replace `mon_123` with your monitor's `id`. You get the results in `data`, newest first. Each one has a `summary`, an `importance` from 1 to 5, and `same_story`, the number of pages on the same story that were left out. Store the first `id` and stop at it on the next poll. An empty `data` on a new monitor is expected: it matches only pages crawled after it was created.

## SDK, CLI and MCP

| Client | Call |
| - | - |
| Python | `client.monitors.results(monitor_id, min_importance=4)` |
| TypeScript | `client.monitors.results(monitorId, { minImportance: 4 })` |
| Go | `client.Monitors.Results(ctx, monitorID, params)` |
| Rust | `client.monitors().results(monitor_id, &params)` |
| CLI | `keenable monitors results <id>`, with `--min-importance`, `--limit`, `--cursor` |
| MCP | `get_monitor_results`. It returns the results a reader hasn't seen yet. With `includeSeen` and a `monitorId`, it returns that monitor's results newest first, read or not. |

The SDK methods need SDK 0.2.0 or later. See [SDKs → Monitors](https://docs.keenable.ai/sdks.md#monitors), [CLI → Monitors](https://docs.keenable.ai/cli.md#monitors) and [Monitors tools](https://docs.keenable.ai/mcp-server.md#monitors-tools).

## Related operations

* [List runs](https://docs.keenable.ai/api-reference/monitors/runs.md) shows the same results grouped by the run that returned them.
* [Read the results](https://docs.keenable.ai/products/monitors#read-the-results) compares webhooks, runs and polling.
* [Create a monitor](https://docs.keenable.ai/api-reference/monitors/create.md) with `search.content.text` to add each page's text.

[Read monitor results](https://docs.keenable.ai/guides/read-monitor-results.md) shows the polling loop.


## OpenAPI

````yaml GET /v1/monitors/{id}/results
openapi: 3.0.3
info:
  title: Keenable API
  version: 1.0.0
  description: Web search, page fetching and monitors API.
servers:
  - url: https://api.keenable.ai
    description: Production
security:
  - apiKey: []
  - bearerAuth: []
paths:
  /v1/monitors/{id}/results:
    get:
      tags:
        - Monitors
      summary: List a monitor's results
      description: >-
        Every result the monitor accepted, newest first, one per story, whether
        or not a run or webhook delivered it. Covers the monitor's last 500
        results. To read a monitor without a webhook or schedule, poll this and
        stop at the first `id` you've already seen.
      operationId: monitors.results
      parameters:
        - $ref: '#/components/parameters/MonitorId'
        - name: min_importance
          in: query
          required: false
          schema:
            type: integer
            minimum: 1
            maximum: 5
          description: >-
            Only results rated at least this important. `4` keeps the results a
            reader wouldn't want to miss.
        - $ref: '#/components/parameters/MonitorLimit'
        - $ref: '#/components/parameters/MonitorCursor'
      responses:
        '200':
          description: A page of results
          headers:
            X-Request-Id:
              $ref: '#/components/headers/XRequestId'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MonitorResultList'
        '400':
          $ref: '#/components/responses/MonitorBadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/MonitorForbidden'
        '404':
          $ref: '#/components/responses/MonitorNotFound'
        '429':
          $ref: '#/components/responses/MonitorRateLimited'
        '503':
          $ref: '#/components/responses/MonitorsUnavailable'
      x-codeSamples:
        - lang: typescript
          label: TypeScript
          source: |
            import { Keenable } from "keenable";

            async function main() {
              // reads KEENABLE_API_KEY from the environment
              const client = new Keenable();
              const results = await client.monitors.results("mon_3kq9z2c8f1a04b7d9e6f5a21", { limit: 10 });
              for (const result of results.data) {
                console.log(result.importance, result.title, result.url);
              }
            }

            main();
        - lang: python
          label: Python
          source: >
            from keenable import Keenable


            # reads KEENABLE_API_KEY from the environment

            client = Keenable()

            results = client.monitors.results("mon_3kq9z2c8f1a04b7d9e6f5a21",
            limit=10)

            for result in results.data:
                print(result.importance, result.title, result.url)
        - lang: go
          label: Go
          source: "package main\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"log\"\n\n\t\"github.com/keenableai/keenable-sdk/go\"\n)\n\nfunc main() {\n\t// reads KEENABLE_API_KEY from the environment\n\tclient, err := keenable.New(nil)\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tdefer client.Close()\n\n\tresults, err := client.Monitors.Results(context.Background(), \"mon_3kq9z2c8f1a04b7d9e6f5a21\", &keenable.MonitorResultsParams{Limit: 10})\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\tfor _, result := range results.Data {\n\t\timportance, title := 0, \"\"\n\t\tif result.Importance != nil {\n\t\t\timportance = *result.Importance\n\t\t}\n\t\tif result.Title != nil {\n\t\t\ttitle = *result.Title\n\t\t}\n\t\tfmt.Println(importance, title, result.URL)\n\t}\n}\n"
        - lang: rust
          label: Rust
          source: |
            use keenable::{Client, MonitorResultsParams};

            #[tokio::main]
            async fn main() -> Result<(), keenable::Error> {
                // reads KEENABLE_API_KEY from the environment
                let client = Client::new()?;
                let results = client
                    .monitors()
                    .results(
                        "mon_3kq9z2c8f1a04b7d9e6f5a21",
                        &MonitorResultsParams { limit: Some(10), ..Default::default() },
                    )
                    .await?;
                for result in results.data {
                    let importance = result.importance.unwrap_or_default();
                    let title = result.title.unwrap_or_default();
                    println!("{importance} {title} {}", result.url);
                }
                Ok(())
            }
        - lang: bash
          label: curl
          source: >
            curl -G
            https://api.keenable.ai/v1/monitors/mon_3kq9z2c8f1a04b7d9e6f5a21/results
            \
              -H "X-API-Key: $KEENABLE_API_KEY" \
              --data-urlencode "limit=10"
components:
  parameters:
    MonitorId:
      name: id
      in: path
      required: true
      schema:
        type: string
      description: The monitor's ID, such as `mon_3kq9z2c8f1a04b7d9e6f5a21`.
      example: mon_3kq9z2c8f1a04b7d9e6f5a21
    MonitorLimit:
      name: limit
      in: query
      required: false
      schema:
        type: integer
        minimum: 1
        maximum: 100
        default: 50
      description: Items per page, 1 to 100. Any other value returns `400`.
    MonitorCursor:
      name: cursor
      in: query
      required: false
      schema:
        type: string
      description: >-
        The `next_cursor` of the previous page. A cursor that isn't in the list
        returns `400`.
  headers:
    XRequestId:
      description: ID of this request. Include it when you report a problem.
      schema:
        type: string
    RetryAfter:
      description: Seconds to wait before retrying.
      schema:
        type: integer
      example: 1
  schemas:
    MonitorResultList:
      type: object
      required:
        - data
        - has_more
        - next_cursor
      properties:
        data:
          type: array
          items:
            $ref: '#/components/schemas/MonitorResultListItem'
        has_more:
          type: boolean
          description: '`true` if there are more items after this page.'
        next_cursor:
          type: string
          nullable: true
          description: Pass it as `cursor` to get the next page. `null` on the last page.
    MonitorResultListItem:
      type: object
      required:
        - id
        - url
        - same_story
      properties:
        id:
          type: string
          description: >-
            Identifies this match. Opaque. The last `id` of a page of results is
            its `next_cursor`.
        url:
          type: string
          example: https://huggingface.co/blog/example-model
        title:
          type: string
          nullable: true
        author:
          type: string
          nullable: true
          description: >-
            When the page names one. Always `null` in `monitor.result.found`
            events.
        published_at:
          type: string
          format: date-time
          nullable: true
          description: >-
            When the page was published, as far as Keenable could establish it.
            A monitor doesn't send a page it couldn't date, so this is `null`
            only in rare cases, such as a changed page (one with `change`) that
            declares no date.
        published_at_source:
          type: string
          nullable: true
          description: >-
            Where `published_at` comes from: `declared` (the page's metadata),
            `url` (a date in the URL), `x` (the ID of an X post) or `text` (the
            page text). `url` and `text` dates are known to the day.
        acquired_at:
          type: string
          format: date-time
          nullable: true
          description: When Keenable's crawler fetched this version of the page.
        matched_at:
          type: string
          format: date-time
          nullable: true
          description: When the monitor accepted the page. Sort and deduplicate on it.
        image:
          type: string
          nullable: true
          description: >-
            The page's lead image. Always `null` in `monitor.result.found`
            events.
        summary:
          type: string
          nullable: true
          description: One line on what the page reports.
        importance:
          type: integer
          minimum: 1
          maximum: 5
          nullable: true
          description: >-
            How much the page matters for this monitor's topic, from 1 to 5.
            Pages under 3 aren't accepted.
        kind:
          type: string
          nullable: true
          description: >-
            `news`, `new_item` (a new release, listing or filing),
            `social_chatter` or `other`.
        source_type:
          type: string
          nullable: true
          description: >-
            `original` (the source or first-hand reporting) or `rewrite`
            (retells another outlet).
        text:
          type: string
          description: The page text, with `search.content.text`. Left out after 3 days.
        change:
          $ref: '#/components/schemas/MonitorChange'
        same_story:
          type: integer
          description: How many more pages reported the same story and were left out.
    ApiError:
      type: object
      required:
        - error
      properties:
        error:
          type: string
          description: Short error title, such as `Invalid parameter` or `Not found`.
          example: Invalid parameter
        message:
          type: string
          description: What went wrong and what to change. Sometimes absent.
          example: '"max_results": must be an integer between 1 and 50'
        details:
          description: Structured details, when the error has any.
        retryAfter:
          type: integer
          description: >-
            Seconds to wait before retrying. Present on `429` responses from
            Keenable's own rate limits, matching the `Retry-After` header.
    MonitorChange:
      type: object
      description: On a page you already got that changed in substance.
      properties:
        previous_at:
          type: string
          nullable: true
          description: When the earlier version was matched.
        previous_title:
          type: string
          nullable: true
        previous_sent:
          type: boolean
          nullable: true
        ratio:
          type: number
          nullable: true
          description: How much of the text changed.
        added:
          nullable: true
          description: Text the new version added.
        removed:
          nullable: true
          description: Text the new version removed.
  responses:
    MonitorBadRequest:
      description: >-
        The request is invalid. `code` is `invalid_request` for a missing or
        wrong field or a schedule that breaks a rule, and
        `monitor_option_not_supported` for a field Monitors doesn't have or
        doesn't offer yet. `message` names the field. Correct the request;
        retrying unchanged returns the same error.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiError'
    Unauthorized:
      description: >-
        No key was sent (`Missing authentication`), or the key is malformed,
        unknown or has the wrong prefix (`Authentication failed`, with
        `Malformed API key` or `Invalid API key` in `message`). Send a valid key
        in `X-API-Key` or `Authorization: Bearer`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiError'
    MonitorForbidden:
      description: >-
        Your key is valid but can't do this. `monitors_not_enabled`: Monitors is
        turned off for your organization; contact support@keenable.ai.
        `monitor_limit_reached`: your organization already has 100 active
        monitors; pause or delete one, then retry.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiError'
    MonitorNotFound:
      description: >-
        No monitor or run with this ID belongs to your organization
        (`not_found`). Check the ID.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiError'
    MonitorRateLimited:
      description: >-
        Your organization sent more than 120 Monitors requests, or more than 10
        creates, in the last minute (`rate_limited`). Wait, then retry.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiError'
      headers:
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
    MonitorsUnavailable:
      description: >-
        The Monitors service didn't answer (`monitors_unavailable`). The request
        may not have been applied. Retry after a few seconds; retry a create
        with the same `Idempotency-Key`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiError'
      headers:
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
  securitySchemes:
    apiKey:
      type: apiKey
      in: header
      name: X-API-Key
      description: >-
        Your API key, such as `keen_...`. Create one in the Keenable console. If
        you send both this header and `Authorization`, the API uses this one.
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Your API key sent as `Authorization: Bearer keen_...`, for clients that
        only support bearer tokens.

````

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