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

# Search

> Search the web, news, images, scholarly papers and YouTube videos in one call.

Best when you want web results, news, images or all three at once, grouped by type, with the page text of the top web results if you ask for it.

> [!NOTE]
>
> Works without an API key within the free limits. See [Rate limits](https://docs.stophy.dev/production/rate-limits.md).

```bash cURL theme={null}
curl -X POST https://api.stophy.dev/v1/search \
  -H "Authorization: Bearer $STOPHY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"nvidia earnings","sources":["web","news"],"limit":5}'
```

```json 200 theme={null}
{
  "success": true,
  "data": {
    "news": [
      {
        "title": "Nvidia earnings live updates: Wall Street braces for first report since Huang's ouster",
        "url": "https://www.cnbc.com/2026/11/17/nvidia-nvda-earnings-report-q3-2027.html",
        "snippet": "Nvidia is scheduled to release fiscal third-quarter 2027 results Tuesday, November 17, at approximately 4:20 p.m. ET,…",
        "date": "2026-11-17T12:49:26.000Z",
        "imageUrl": "https://example.com/",
        "position": 1
      }
    ],
    "web": [
      {
        "url": "https://www.cnbc.com/2026/11/17/nvidia-nvda-earnings-report-q3-2027.html",
        "title": "Nvidia earnings live updates: Wall Street braces for first report since Huang's ouster",
        "description": "Growth remains explosive, with revenue expansion expected to reach 91% in the latest quarter from $59 billion in the…",
        "position": 1,
        "date": "2026-11-17T00:00:00.000Z"
      }
    ]
  }
}
```


## OpenAPI

````yaml api-reference/openapi.json POST /v1/search
openapi: 3.1.0
info:
  title: Stophy API
  version: '1'
  description: >-
    Each operation shows its method and its input: a JSON object body, path and
    query parameters, or a file upload.


    Responses leave out empty values: null, empty strings, empty objects and
    empty nested lists are not sent.


    Text comes back whole. To get shorter responses, add
    ?maxTextLength=<characters> to the URL. Every text value longer than that is
    cut and ends with …. A screenshot is never cut, and a page whose text was
    cut has isTruncated set to true.


    The x-cost-usd response header is what the request cost in dollars. An
    operation's description gives its pricing units and add-ons. The OpenAPI
    fields x-cost-usd and x-cost-usd-max are list-price estimates, not receipts
    or spending limits. When a call starts a job, check the job result for its
    total cost.


    When a response has a cursor, send it back unchanged with the same input to
    get the next page. When it has a page, send the next page number.
servers:
  - url: https://api.stophy.dev
security:
  - apiKey: []
paths:
  /v1/search:
    post:
      summary: >-
        Search the web, news, images, scholarly papers and YouTube videos in one
        call
      description: >-
        Costs $0.001 per block of up to 10 returned results, counted separately
        for each source and each research or videos list ($1 per 1,000
        single-source searches returning 1 to 10 results). With
        scrapeOptions.formats, page reads and their add-ons use scrape pricing,
        starting at $1 per 1,000 pages for a standard read.
      operationId: search
      parameters:
        - $ref: '#/components/parameters/MaxTextLength'
        - $ref: '#/components/parameters/IdempotencyKey'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                query:
                  description: >-
                    What to search for, up to 500 characters. Search operators
                    work in web results: quotes for an exact phrase, -word,
                    site:, -site:, filetype:, inurl:, allinurl:, intitle: and
                    allintitle:. In image results, imagesize:WIDTHxHEIGHT keeps
                    images of exactly that size and larger:WIDTHxHEIGHT keeps
                    images at least that large.
                  type: string
                  minLength: 1
                  maxLength: 500
                sources:
                  description: >-
                    What to search: web, news, images. Each is a string or
                    {type}. Default web, or none when categories asks for
                    research or videos.
                  minItems: 1
                  maxItems: 5
                  type: array
                  items:
                    anyOf:
                      - type: string
                        enum:
                          - web
                          - news
                          - images
                      - type: object
                        properties:
                          type:
                            type: string
                            const: web
                          tbs:
                            type: string
                          location:
                            type: string
                          country:
                            type: string
                            pattern: ^[A-Za-z]{2}$
                            description: >-
                              ISO 3166-1 alpha-2 country code, e.g. us. Any case
                              is accepted.
                          lang:
                            description: >-
                              Two-letter language for web results, like de. A
                              web source that does not support this language for
                              the selected country can return results in another
                              language with a warning.
                            type: string
                            pattern: ^[A-Za-z]{2}$
                        required:
                          - type
                        additionalProperties: false
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - news
                              - images
                        required:
                          - type
                        additionalProperties: false
                categories:
                  description: >-
                    pdf: web results that are PDF files. research: scholarly
                    papers, in a research list, ranked by relevance then
                    citations. videos: YouTube videos for the query, in
                    YouTube's order, in a videos list, with the channel, length,
                    views and watch link; a video whose captions we hold also
                    gets the passage that matches the query and where it starts.
                  type: array
                  items:
                    anyOf:
                      - type: string
                        enum:
                          - research
                          - pdf
                          - videos
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - research
                              - pdf
                              - videos
                        required:
                          - type
                        additionalProperties: false
                maxAge:
                  description: >-
                    Accept a stored answer up to this many milliseconds old, at
                    most 30 days. Without it, 15 minutes for news and 1 hour for
                    web and images. 0 always searches live.
                  type: integer
                  minimum: 0
                  maximum: 9007199254740991
                limit:
                  description: >-
                    Most results to return for each source. Default 10, or 5
                    when scrapeOptions has formats, which reads every web and
                    news result returned unless scrapeLimit sets fewer. News
                    returns at most 50.
                  type: integer
                  minimum: 1
                  maximum: 100
                scrapeLimit:
                  description: >-
                    With scrapeOptions formats: read only the top this many web
                    results and the top this many news results, and return the
                    other results without page text. Cannot be more than limit.
                    Without it every result returned is read. Only pages that
                    are read are charged for.
                  type: integer
                  minimum: 1
                  maximum: 100
                tbs:
                  description: >-
                    Time filter: qdr:d, qdr:w, qdr:m or qdr:y, or
                    cdr:1,cd_min:MM/DD/YYYY,cd_max:MM/DD/YYYY, plus sbd:1, like
                    sbd:1,qdr:w. sbd:1 sorts newest first; results without a
                    date come last. Web takes all of them; news takes qdr and
                    sbd; images take none.
                  type: string
                  minLength: 1
                location:
                  description: >-
                    Where to search from, like Germany or San
                    Francisco,California,United States. The last part is the
                    country and replaces country. A city before it narrows web
                    results to that place.
                  type: string
                  minLength: 1
                country:
                  description: >-
                    Two-letter country to search from, like us. uk is read as
                    gb. Image results are always US.
                  type: string
                  pattern: ^[A-Za-z]{2}$
                lang:
                  description: >-
                    Two-letter language preference, like de. Applies to web
                    results when web is selected, otherwise to news where
                    supported. Results from a source that cannot honor it may be
                    in another language and come with a warning.
                  type: string
                  pattern: ^[A-Za-z]{2}$
                includeDomains:
                  type: array
                  items:
                    type: string
                  maxItems: 10
                excludeDomains:
                  type: array
                  items:
                    type: string
                  maxItems: 10
                safe:
                  description: Hide explicit web, news and image results when true.
                  type: boolean
                timeout:
                  description: >-
                    Milliseconds to wait for the sources, from 1,000 to 120,000;
                    more is read as 120,000. Default 3,000, or 60,000 when
                    scrapeOptions has formats and the search reads pages. A
                    source that has not answered by then is left out with a
                    warning. When none has, the call fails and costs nothing.
                  type: integer
                  minimum: 1000
                  maximum: 9007199254740991
                ignoreInvalidURLs:
                  default: false
                  description: Leave out results whose address cannot be read as a page.
                  type: boolean
                highlights:
                  default: false
                  description: >-
                    Off by default. With true, a web result whose page we
                    already hold gets the passages that best match the query as
                    its description, in markdown, up to about 2,000 characters;
                    others keep the engine's snippet.
                  type: boolean
                scrapeOptions:
                  description: >-
                    With formats, reads each web and news result, as many as
                    scrapeLimit or limit asks for, within timeout, and fills
                    each web result's description from it. Without formats no
                    page is read and nothing more is charged. Takes the options
                    of scrape: formats (markdown, html, rawHtml, links, images,
                    summary, screenshot, json and the rest), onlyMainContent,
                    includeTags, excludeTags, maxAge, minAge, waitFor, mobile,
                    timeout (per page), headers, actions, location, parsers,
                    profile and zeroDataRetention. redactPII uses patterns on
                    web descriptions, news snippets, research snippets and video
                    snippets, even without formats, when sources has web or
                    news. Titles and URLs are unchanged. Snippets can still
                    contain names and places that patterns miss. With formats,
                    page reads and their add-ons use scrape pricing, starting at
                    $1 per 1,000 pages for a standard read.
                  type: object
                  properties:
                    formats:
                      description: >-
                        What to return: markdown (clean page text), summary (a
                        short summary of the page), html (the cleaned page),
                        rawHtml (the page as sent), audio and video (for a
                        YouTube link: the audio track as an M4A file, or the
                        video as an MP4 file, as a link that works for 1 hour),
                        rawBase64 (the bytes the site sent, Base64 encoded, from
                        a live read; metadata.contentType says what they are),
                        links (every link on the page), images (every image
                        address), screenshot (a link to a JPEG of the visible
                        page, kept for 7 days), changeTracking (what changed in
                        the markdown since your key last read this page with the
                        same options, kept 30 days; add modes
                        ["git-diff","json"] with a schema or prompt to compare
                        fields too), question (send { "type": "question",
                        "question": "..." } to get answer, left out with a
                        warning when the page does not state one), product
                        (title, brand, category, url, description and variants
                        with price, sale, availability and images, left out with
                        a warning when there is none) and menu (merchant,
                        currency and sections of items with prices, left out
                        with a warning when there is none) network (the JSON the
                        page loaded while it rendered, up to 30 responses) and
                        branding (the page's colors, fonts, typography, spacing,
                        button and input styles, logo and brand images, read
                        from how the page looks, with a field left out when the
                        page does not show it). Send { "type": "screenshot",
                        "fullPage": true } for the whole page. Send { "type":
                        "highlights", "query": "refund policy" } for the
                        passages that best match a query. Send { "type": "json",
                        "schema": { "type": "object", "properties": { "price": {
                        "type": "number" } } } } or { "type": "json", "prompt":
                        "the price and the stock" } for fields filled from the
                        page, each checked against it. Send { "type": "json",
                        "parser": "amazon-product" } to get a site's own data as
                        json instead of reading the page; GET /v1/parsers lists
                        the parsers. Send { "type": "json", "rules": { "title":
                        "h1", "links": { "selector": "a", "type": "list",
                        "output": "@href" } } } to read the page with CSS rules
                        and no model, at the page's own price. Send { "type":
                        "attributes", "selectors": [{ "selector": "a",
                        "attribute": "href" }] } for attribute values, returned
                        in attributes. Without a parser or rules, json needs a
                        schema or a prompt and is filled from the page. json
                        with a schema or a prompt, summary, highlights,
                        question, product, menu and changeTracking in json mode
                        add $3 per 1,000 pages each when they return something.
                        JSON with CSS rules and attributes add nothing. A named
                        parser uses its own price. Any page read or other paid
                        format you ask for is charged separately. A screenshot,
                        network or branding read costs $1 per 1,000 pages, the
                        same as any page. A PDF comes back as markdown only, and
                        adds $0.50 per 1,000 pages of text from its text layer
                        and $2.50 per 1,000 pages of text read from its picture
                        that comes back. A CSV or an Excel .xlsx file comes back
                        as markdown tables.
                      default:
                        - markdown
                      minItems: 1
                      maxItems: 20
                      type: array
                      items:
                        anyOf:
                          - type: string
                            enum:
                              - markdown
                              - summary
                              - html
                              - rawHtml
                              - rawBase64
                              - links
                              - images
                              - network
                              - branding
                              - audio
                              - video
                              - screenshot
                              - changeTracking
                              - product
                              - menu
                          - type: object
                            properties:
                              type:
                                type: string
                                enum:
                                  - markdown
                                  - summary
                                  - html
                                  - rawHtml
                                  - rawBase64
                                  - links
                                  - images
                                  - network
                                  - branding
                                  - audio
                                  - video
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: changeTracking
                              modes:
                                description: >-
                                  git-diff returns a unified diff of the
                                  markdown. json compares the fields in schema
                                  or prompt between this read and the last one.
                                  Without modes you get git-diff.
                                maxItems: 2
                                type: array
                                items:
                                  type: string
                                  enum:
                                    - git-diff
                                    - json
                              schema:
                                description: >-
                                  The fields to fill, as a JSON Schema (draft-07
                                  or 2020-12) object with properties. Pydantic's
                                  model_json_schema() and zod's toJSONSchema()
                                  output work as they are. enum, const, anyOf,
                                  oneOf, nullable types, $ref with $defs,
                                  required, descriptions and any key names are
                                  read. Up to 100 top-level fields and 32 KB. A
                                  field the page does not state comes back null.
                                type: object
                                propertyNames:
                                  type: string
                                additionalProperties:
                                  $ref: '#/components/schemas/search.input.schema0'
                              prompt:
                                description: >-
                                  With json mode: what to compare, in plain
                                  words, such as the price and stock.
                                type: string
                                minLength: 1
                                maxLength: 10000
                              tag:
                                type: 'null'
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: question
                              question:
                                type: string
                                minLength: 1
                                maxLength: 10000
                                description: >-
                                  A question to answer from the page, such as
                                  what the refund window is.
                            required:
                              - type
                              - question
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: product
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: menu
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: screenshot
                              fullPage:
                                default: false
                                description: >-
                                  Capture the whole page from top to bottom
                                  instead of the visible part.
                                type: boolean
                              quality:
                                description: JPEG quality from 1 to 100. The default is 70.
                                type: integer
                                minimum: 1
                                maximum: 100
                              viewport:
                                description: >-
                                  The window size in pixels, such as { width:
                                  390, height: 844 }.
                                type: object
                                properties:
                                  width:
                                    type: integer
                                    minimum: 200
                                    maximum: 3840
                                  height:
                                    type: integer
                                    minimum: 200
                                    maximum: 2160
                                required:
                                  - width
                                  - height
                                additionalProperties: false
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: highlights
                              query:
                                type: string
                                minLength: 1
                                maxLength: 10000
                                description: >-
                                  What you are looking for on the page, such as
                                  refund policy.
                              count:
                                default: 5
                                description: How many passages to return, best match first.
                                type: integer
                                minimum: 1
                                maximum: 20
                            required:
                              - type
                              - query
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: json
                              parser:
                                description: >-
                                  Read the page with a named parser, which gives
                                  the site's own data as json. The url must be
                                  the kind of page the parser reads. Parsers are
                                  the only way to read some sites. GET
                                  /v1/parsers lists them.
                                type: string
                              options:
                                description: >-
                                  Only with parser: extra inputs for it, such as
                                  { "page": 2 } for the next page of results or
                                  { "minRating": 4.5 } for a filter. GET
                                  /v1/parsers lists what each parser accepts.
                                type: object
                                propertyNames:
                                  type: string
                                additionalProperties:
                                  $ref: '#/components/schemas/search.input.schema1'
                              schema:
                                description: >-
                                  The fields to fill, as a JSON Schema (draft-07
                                  or 2020-12) object with properties. Pydantic's
                                  model_json_schema() and zod's toJSONSchema()
                                  output work as they are. enum, const, anyOf,
                                  oneOf, nullable types, $ref with $defs,
                                  required, descriptions and any key names are
                                  read. Up to 100 top-level fields and 32 KB. A
                                  field the page does not state comes back null.
                                type: object
                                propertyNames:
                                  type: string
                                additionalProperties:
                                  $ref: '#/components/schemas/search.input.schema0'
                              prompt:
                                description: >-
                                  What to pull from the page in plain words,
                                  such as the version and the release date.
                                type: string
                                minLength: 1
                                maxLength: 10000
                              rules:
                                description: >-
                                  Read the page with CSS rules instead of a
                                  model, no extra fee. Each field is a selector
                                  such as "h1" (the first match's text),
                                  "a@href" (an attribute) or { "selector": "li",
                                  "type": "list", "output": "text" | "html" |
                                  "@attribute" | { nested fields } }. A missing
                                  item is null and an unmatched list is [].
                                  Relative links become absolute. Up to 100
                                  fields, 5 levels deep. Not with schema, prompt
                                  or parser.
                                type: object
                                propertyNames:
                                  type: string
                                additionalProperties:
                                  $ref: '#/components/schemas/search.input.schema2'
                              checkPromptInjection:
                                description: >-
                                  Deprecated: send checkPromptInjection at the
                                  top level of the call.
                                type: boolean
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: attributes
                              selectors:
                                minItems: 1
                                maxItems: 50
                                type: array
                                items:
                                  type: object
                                  properties:
                                    selector:
                                      type: string
                                      minLength: 1
                                    attribute:
                                      type: string
                                      minLength: 1
                                      maxLength: 100
                                  required:
                                    - selector
                                    - attribute
                                  additionalProperties: false
                                description: >-
                                  The elements and attributes to read, such as {
                                  selector: 'a.buy', attribute: 'href' }.
                            required:
                              - type
                              - selectors
                            additionalProperties: false
                    onlyMainContent:
                      default: true
                      description: >-
                        Keep only the page's main content, without menus,
                        headers, footers and ads.
                      type: boolean
                    onlyCleanContent:
                      description: >-
                        Send true to have a model remove what onlyMainContent
                        leaves behind in the markdown: cookie banners, ads,
                        share widgets, breadcrumbs, sign-up prompts, comment
                        prompts and related-article lists. It only removes whole
                        paragraphs and lists; it never rewrites or adds text,
                        and code blocks are always kept. Skipped with a warning
                        when the page is too long to clean or the model does not
                        answer. Not with zeroDataRetention. Summary, answers and
                        highlights are made from the cleaned markdown.
                      type: boolean
                    includeTags:
                      description: >-
                        Keep only the parts of the page that match these CSS
                        selectors, such as article or .price. When set,
                        onlyMainContent is not applied.
                      minItems: 1
                      type: array
                      items:
                        type: string
                        minLength: 1
                    excludeTags:
                      description: >-
                        Remove the parts of the page that match these CSS
                        selectors, such as .comments.
                      minItems: 1
                      type: array
                      items:
                        type: string
                        minLength: 1
                    maxAge:
                      description: >-
                        Accept a stored answer up to this many milliseconds old,
                        at most 30 days. Without it, 2 days, or less for a site
                        whose pages change often, and a copy up to twice that
                        age (at most 7 days) comes back at once as stale while a
                        fresh read runs. 0 always reads the page live.
                        metadata.cacheState says which one you got.
                      type: integer
                      minimum: 0
                      maximum: 9007199254740991
                    minAge:
                      description: >-
                        Answer only from a stored copy that is at least this
                        many milliseconds old, and never read the page live. 0
                        accepts any stored copy. A page with no such copy is
                        notFound.
                      type: integer
                      minimum: 0
                      maximum: 9007199254740991
                    headers:
                      description: >-
                        Extra request headers to send to the site, such as {
                        "x-plan": "pro" }. A read with headers is never answered
                        from or saved to a stored copy.
                      type: object
                      propertyNames:
                        type: string
                        pattern: ^[A-Za-z0-9-]{1,64}$
                      additionalProperties:
                        type: string
                        maxLength: 2000
                        pattern: ^[\t\x20-\x7e]*$
                    waitFor:
                      description: >-
                        Extra milliseconds to wait before reading, up to 60000,
                        for pages that load their content late. To wait for an
                        element, add a wait action with a selector. A read that
                        waits costs $1 per 1,000 pages, the same as any page.
                      type: integer
                      minimum: 0
                      maximum: 60000
                    mobile:
                      description: >-
                        Read the page as a phone would: a phone-sized screen and
                        the mobile version of the site. The page loads in a
                        browser.
                      type: boolean
                    skipTlsVerification:
                      description: >-
                        Send true to read a page whose certificate is expired,
                        self-signed or for another name. The read is not private
                        against someone between us and the site.
                      type: boolean
                    timeout:
                      default: 30000
                      description: >-
                        How long to keep trying, in milliseconds, from 1 second
                        to 5 minutes; 30 seconds by default. A page that needs a
                        browser needs at least 5 seconds, and pages behind a bot
                        check can need 10 to 30 seconds the first time. A read
                        that runs out of time is an error and costs nothing.
                      type: integer
                      minimum: 1000
                      maximum: 300000
                    parsers:
                      description: >-
                        Only the pdf parser exists. Send "pdf" or { "type":
                        "pdf", mode, maxPages, pages, blocks, pageMarkers } with
                        the same meaning as in parse. Without mode a PDF is read
                        as auto: from its text layer, and from the picture of
                        any page that has no text. fast reads the text layer
                        only, and ocr reads the picture of every page, up to 20
                        pages. Each page of text that comes back costs $0.50 per
                        1,000 pages from its text layer and $2.50 per 1,000
                        pages from its picture. Pictures are read only with an
                        API key.
                      minItems: 1
                      type: array
                      items:
                        anyOf:
                          - type: string
                            const: pdf
                          - type: object
                            properties:
                              type:
                                type: string
                                const: pdf
                              mode:
                                description: >-
                                  fast reads the text layer only. auto (the
                                  default) reads the text layer and reads the
                                  picture of any page that has none. ocr reads
                                  the picture of every page.
                                type: string
                                enum:
                                  - fast
                                  - auto
                                  - ocr
                              maxPages:
                                description: >-
                                  Read at most this many pages, up to 500, which
                                  is also the default.
                                type: integer
                                minimum: 1
                                maximum: 500
                              pages:
                                description: >-
                                  Send true to also get each page's markdown in
                                  pages, as { pageNumber, markdown }. No extra
                                  charge.
                                type: boolean
                              blocks:
                                description: >-
                                  Send true to also get the page's layout in
                                  blocks: each title, section header or run of
                                  text, with its page, reading order, position
                                  on the page (bbox as left, top, right, bottom
                                  from 0 to 1) and where its text sits in that
                                  page's markdown (span, as in pages). Tables,
                                  figures and formulas are not told apart. A
                                  page read from its picture is one block. No
                                  extra charge.
                                type: boolean
                              pageMarkers:
                                description: >-
                                  Send true to mark page breaks in the markdown:
                                  pages are joined with "---" and a <!-- page N
                                  --> line, where N is the page that follows. No
                                  extra charge.
                                type: boolean
                            required:
                              - type
                            additionalProperties: false
                    actions:
                      description: >-
                        Up to 50 steps to run on the page, in order, before
                        reading it: { "type": "wait", "milliseconds": 500 } (up
                        to 60 seconds), { "type": "wait", "selector": ".results"
                        }, { "type": "click", "selector": "button.more" }, {
                        "type": "write", "text": "tides" }, { "type": "press",
                        "key": "Enter" }, { "type": "scroll", "direction":
                        "down" } (also up, left or right; amount is pixels,
                        "viewport" or "max"; maxScrolls 1 to 50; selector
                        scrolls an inner container; "max" keeps scrolling until
                        the page stops growing, for feeds that load as you go),
                        { "type": "screenshot", "fullPage": true } (links come
                        back in actions.screenshots), { "type": "scrape" } (the
                        page at that point, in actions.scrapes), { "type":
                        "executeJavascript", "script": "document.title" }
                        (results in actions.javascriptReturns), { "type": "pdf",
                        "format": "A4" } (links in actions.pdfs) or { "type":
                        "perform", "action": "Click the Load more button" } (a
                        step in plain words, up to 5 browser steps on this page,
                        never leaving the site; at most 5 per call). A read with
                        actions costs $1 per 1,000 pages, the same as any page;
                        the actions themselves add nothing. If an action fails,
                        you still get the page as it stood, with a warning that
                        names the action and says why.
                      minItems: 1
                      maxItems: 50
                      type: array
                      items:
                        anyOf:
                          - type: object
                            properties:
                              type:
                                type: string
                                const: wait
                              milliseconds:
                                type: integer
                                minimum: 1
                                maximum: 60000
                            required:
                              - type
                              - milliseconds
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: wait
                              selector:
                                type: string
                                minLength: 1
                            required:
                              - type
                              - selector
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: click
                              selector:
                                type: string
                                minLength: 1
                              all:
                                type: boolean
                                const: false
                            required:
                              - type
                              - selector
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: write
                              text:
                                type: string
                                minLength: 1
                            required:
                              - type
                              - text
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: press
                              key:
                                type: string
                                minLength: 1
                                maxLength: 40
                            required:
                              - type
                              - key
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: scroll
                              direction:
                                default: down
                                type: string
                                enum:
                                  - up
                                  - down
                                  - left
                                  - right
                              amount:
                                anyOf:
                                  - type: integer
                                    minimum: 1
                                    maximum: 100000
                                  - type: string
                                    enum:
                                      - viewport
                                      - max
                              maxScrolls:
                                type: integer
                                minimum: 1
                                maximum: 50
                              selector:
                                type: string
                                minLength: 1
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: screenshot
                              fullPage:
                                type: boolean
                              quality:
                                type: integer
                                minimum: 1
                                maximum: 100
                              viewport:
                                type: object
                                properties:
                                  width:
                                    type: integer
                                    minimum: 200
                                    maximum: 3840
                                  height:
                                    type: integer
                                    minimum: 200
                                    maximum: 2160
                                required:
                                  - width
                                  - height
                                additionalProperties: false
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: scrape
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: executeJavascript
                              script:
                                type: string
                                minLength: 1
                                maxLength: 20000
                            required:
                              - type
                              - script
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: pdf
                              format:
                                type: string
                                enum:
                                  - Letter
                                  - Legal
                                  - Tabloid
                                  - Ledger
                                  - A0
                                  - A1
                                  - A2
                                  - A3
                                  - A4
                                  - A5
                                  - A6
                              landscape:
                                type: boolean
                              scale:
                                type: number
                                minimum: 0.1
                                maximum: 2
                            required:
                              - type
                            additionalProperties: false
                          - type: object
                            properties:
                              type:
                                type: string
                                const: perform
                              action:
                                type: string
                                minLength: 1
                                maxLength: 500
                            required:
                              - type
                              - action
                            additionalProperties: false
                    location:
                      description: >-
                        Where to read the page from. The default is the United
                        States.
                      type: object
                      properties:
                        country:
                          description: >-
                            Two-letter country code to read the page from, such
                            as DE or JP.
                          type: string
                        languages:
                          description: >-
                            Languages to ask the site for, best first, such as
                            ["de", "en"]. Sent as Accept-Language. A read with
                            languages is never answered from or saved to a
                            stored copy.
                          minItems: 1
                          maxItems: 5
                          type: array
                          items:
                            type: string
                            pattern: ^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$
                      additionalProperties: false
                    removeBase64Images:
                      description: >-
                        Images inside the page that carry their data in the
                        address (data:image) are dropped by default. Send false
                        to keep them in markdown and html.
                      type: boolean
                    blockAds:
                      description: >-
                        Ads and trackers are not loaded when a page runs in a
                        browser. Send false to load them.
                      type: boolean
                    fastMode:
                      description: >-
                        Send true to read the page without opening a browser:
                        the answer comes sooner, but a page that needs a
                        browser, or that refuses a plain request, comes back as
                        an error instead of being retried. Ignored when the call
                        needs a browser (actions, screenshot, waitFor, mobile,
                        profile, network, branding).
                      type: boolean
                    proxy:
                      description: >-
                        auto: basic first, enhanced once if the site refuses.
                        basic: one plain attempt. enhanced: the stronger read
                        from the start. stealth is the same as enhanced. Same
                        price.
                      type: string
                      enum:
                        - auto
                        - basic
                        - enhanced
                        - stealth
                    storeInCache:
                      default: true
                      description: >-
                        Send false to neither read nor keep a stored copy of
                        this page.
                      type: boolean
                    lockdown:
                      description: >-
                        Send true to answer only from a stored copy of the page
                        and never read it live, whatever its age. A page with no
                        stored copy is notFound. The same as minAge 0.
                      type: boolean
                    checkPromptInjection:
                      description: >-
                        Send true to scan the page text for instructions aimed
                        at an AI model before anything is built from it. A page
                        that has them is refused with 403
                        promptInjectionDetected and costs nothing. The scan adds
                        $2.50 per 1,000 pages when it runs; a page it cannot
                        scan fully comes back with a warning and no charge.
                      type: boolean
                    redactPII:
                      description: >-
                        Send true, or an object, to hide personal data in the
                        markdown and in everything made from it (summary,
                        answers, highlights, json). Links, html and rawHtml are
                        not changed. A page the model cannot scan is refused
                        rather than returned unredacted.
                      anyOf:
                        - type: boolean
                        - type: object
                          properties:
                            mode:
                              default: accurate
                              description: >-
                                accurate finds names and places with the model
                                and the rest by pattern. aggressive adds guesses
                                that catch more and may hide a little too much.
                                fast uses patterns only, so it finds no ordinary
                                names or places.
                              type: string
                              enum:
                                - accurate
                                - aggressive
                                - fast
                            entities:
                              default:
                                - PERSON
                                - EMAIL
                                - PHONE
                                - LOCATION
                                - FINANCIAL
                                - SECRET
                              description: >-
                                What to hide: PERSON, EMAIL, PHONE, LOCATION,
                                FINANCIAL, SECRET. All by default.
                              minItems: 1
                              type: array
                              items:
                                type: string
                                enum:
                                  - PERSON
                                  - EMAIL
                                  - PHONE
                                  - LOCATION
                                  - FINANCIAL
                                  - SECRET
                            replaceStyle:
                              default: tag
                              description: >-
                                tag writes <EMAIL>, mask writes * for each
                                character, remove deletes it.
                              type: string
                              enum:
                                - tag
                                - mask
                                - remove
                          additionalProperties: false
                          description: Options for redactPII.
                    profile:
                      description: >-
                        Read the page with the cookies and local storage that
                        earlier calls saved under this name, kept for your
                        account for 30 days after the last use. A call with a
                        profile always loads the page in a browser, costs $1 per
                        1,000 pages, the same as any page, and is never answered
                        from a stored copy. Only one call at a time can save to
                        a profile.
                      type: object
                      properties:
                        name:
                          type: string
                          minLength: 1
                          maxLength: 128
                          description: >-
                            A name you choose, such as shop-login. Calls with
                            the same name share state.
                        saveChanges:
                          default: true
                          description: >-
                            Keep the cookies and local storage this read leaves
                            behind for the next call with this name. Send false
                            to read with the profile without changing it.
                          type: boolean
                      required:
                        - name
                      additionalProperties: false
                    zeroDataRetention:
                      default: false
                      description: >-
                        Send true to keep nothing from this call: no stored copy
                        is read or made, and nothing from it is logged. Adds $2
                        per 1,000 scraped URLs, not per PDF page. Not with a
                        screenshot.
                      type: boolean
                  additionalProperties: false
              required:
                - query
              additionalProperties: false
            example:
              query: nvidia earnings
              sources:
                - web
                - news
              limit: 5
      responses:
        '200':
          description: The data, and what this call cost in dollars.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/RequestId'
            x-credits-used:
              $ref: '#/components/headers/CreditsUsed'
            x-cost-usd:
              $ref: '#/components/headers/CostUsd'
            X-RateLimit-Limit:
              $ref: '#/components/headers/RateLimitLimit'
            X-RateLimit-Remaining:
              $ref: '#/components/headers/RateLimitRemaining'
            X-RateLimit-Reset:
              $ref: '#/components/headers/RateLimitReset'
            x-cache:
              $ref: '#/components/headers/Cache'
            x-cache-age:
              $ref: '#/components/headers/CacheAge'
            idempotent-replayed:
              $ref: '#/components/headers/IdempotentReplayed'
          content:
            application/json:
              schema:
                type: object
                additionalProperties: false
                properties:
                  success:
                    type: boolean
                    const: true
                  data:
                    type: object
                    additionalProperties: false
                    properties:
                      web:
                        type: array
                        items:
                          type: object
                          additionalProperties: false
                          properties:
                            pages:
                              description: >-
                                For a PDF read with the pdf parser and pages
                                true: each page's markdown.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  pageNumber:
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  markdown:
                                    type: string
                                required:
                                  - pageNumber
                            blocks:
                              description: >-
                                For a PDF read with the pdf parser and blocks
                                true: each title, section header or run of text
                                with its page, order, bbox and span.
                              type: array
                              items:
                                type: object
                                propertyNames:
                                  type: string
                                additionalProperties:
                                  $ref: '#/components/schemas/search.schema0'
                            summary:
                              description: A short summary of the page.
                              type: string
                            answer:
                              description: >-
                                The answer to the question format. Left out,
                                with a warning, when the page does not state
                                one.
                              type: string
                            product:
                              description: >-
                                The product the page sells: title, brand,
                                category, url, description and variants, each
                                with its price, sale, availability and images.
                                Left out, with a warning, when the page is not a
                                product page.
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties: {}
                            menu:
                              description: >-
                                The menu on the page: isMenu, confidence,
                                merchant, currency and sections with their
                                items. Left out, with a warning, when the page
                                is not a menu.
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties: {}
                            html:
                              type: string
                            rawHtml:
                              type: string
                            audio:
                              description: >-
                                A link to the audio of a YouTube video as an M4A
                                file. The link works for 1 hour.
                              type: string
                              format: uri
                            video:
                              description: >-
                                A link to a YouTube video as an MP4 file with
                                sound, in the best single-file quality YouTube
                                offers. The link works for 1 hour.
                              type: string
                              format: uri
                            rawBase64:
                              description: >-
                                The bytes the site sent, Base64 encoded, without
                                a data: prefix. metadata.contentType says what
                                they are. Always read live.
                              type: string
                            links:
                              type: array
                              items:
                                type: string
                            images:
                              type: array
                              items:
                                type: string
                            screenshot:
                              description: >-
                                A link to a JPEG of the page. The link works for
                                7 days.
                              type: string
                              format: uri
                            screenshotCropped:
                              description: >-
                                true when the page was taller than the
                                screenshot, so the bottom is cut off.
                              type: boolean
                            highlights:
                              description: >-
                                The passages that best match the highlights
                                query, best first.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  section:
                                    type: string
                                  text:
                                    type: string
                                required: []
                            network:
                              description: >-
                                The JSON responses the page loaded while it
                                rendered, with their bodies.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  url:
                                    type: string
                                  method:
                                    type: string
                                  status:
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  contentType:
                                    type: string
                                  body:
                                    type: string
                                required:
                                  - status
                            branding:
                              description: >-
                                The page's look: colorScheme, logo, colors
                                (hex), fonts, typography, spacing, components,
                                images and layout. Each field is left out or
                                null when the page does not show it.
                              type: object
                              additionalProperties: false
                              properties:
                                colorScheme:
                                  type: string
                                  enum:
                                    - light
                                    - dark
                                logo:
                                  type: string
                                colors:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    primary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    secondary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    accent:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    background:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    textPrimary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    textSecondary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    link:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    success:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    warning:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    error:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                  required: []
                                fonts:
                                  type: array
                                  items:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      family:
                                        type: string
                                        minLength: 1
                                    required:
                                      - family
                                typography:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    fontFamilies:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        primary:
                                          type: string
                                          minLength: 1
                                        heading:
                                          type: string
                                          minLength: 1
                                        code:
                                          type: string
                                          minLength: 1
                                      required: []
                                    fontSizes:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        h1:
                                          type: string
                                          minLength: 1
                                        h2:
                                          type: string
                                          minLength: 1
                                        h3:
                                          type: string
                                          minLength: 1
                                        body:
                                          type: string
                                          minLength: 1
                                      required: []
                                    fontWeights:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        light:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                        regular:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                        medium:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                        bold:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                      required: []
                                    lineHeights:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        heading:
                                          type: string
                                          minLength: 1
                                        body:
                                          type: string
                                          minLength: 1
                                      required: []
                                  required: []
                                spacing:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    baseUnit:
                                      type: integer
                                      minimum: -9007199254740991
                                      maximum: 9007199254740991
                                    borderRadius:
                                      type: string
                                      minLength: 1
                                    padding:
                                      type: object
                                      propertyNames:
                                        type: string
                                      additionalProperties:
                                        type: string
                                        minLength: 1
                                    margins:
                                      type: object
                                      propertyNames:
                                        type: string
                                      additionalProperties:
                                        type: string
                                        minLength: 1
                                  required: []
                                components:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    buttonPrimary:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        background:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        textColor:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        borderRadius:
                                          type: string
                                          minLength: 1
                                      required: []
                                    buttonSecondary:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        background:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        textColor:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        borderColor:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        borderRadius:
                                          type: string
                                          minLength: 1
                                      required: []
                                    input:
                                      type: object
                                      propertyNames:
                                        type: string
                                      additionalProperties:
                                        type: string
                                        minLength: 1
                                  required: []
                                icons:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                images:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    logo:
                                      type: string
                                    favicon:
                                      type: string
                                    ogImage:
                                      type: string
                                  required: []
                                animations:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                layout:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                personality:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                              required:
                                - colorScheme
                            networkDropped:
                              description: >-
                                How many JSON responses were left out because
                                the page loaded too many or they were too big.
                              type: integer
                              exclusiveMinimum: 0
                              maximum: 9007199254740991
                            json:
                              description: >-
                                What you asked for with the json format. A page
                                from a site Stophy reads natively, such as a
                                Reddit post, comes back as its own data. Any
                                other page comes back as the fields in your
                                schema or prompt, each null when the page does
                                not state it.
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties: {}
                            changeTracking:
                              description: >-
                                new the first time your key reads this page,
                                same when nothing changed, changed with a
                                unified diff of the markdown when something did.
                                With json mode, json holds each field's previous
                                and current value.
                              type: object
                              additionalProperties: false
                              properties:
                                status:
                                  type: string
                                  enum:
                                    - new
                                    - same
                                    - changed
                                previousAt:
                                  type: string
                                  format: date-time
                                  pattern: >-
                                    ^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z))$
                                diff:
                                  type: string
                                json:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      previous:
                                        $ref: '#/components/schemas/search.schema0'
                                      current:
                                        $ref: '#/components/schemas/search.schema0'
                                    required: []
                              required:
                                - status
                            attributes:
                              description: >-
                                The values the attributes format read, one entry
                                per selector.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  selector:
                                    type: string
                                  attribute:
                                    type: string
                                  values:
                                    type: array
                                    items:
                                      type: string
                                required: []
                            actions:
                              description: >-
                                What the screenshot, scrape, executeJavascript
                                and pdf actions captured, each in the order the
                                actions ran: screenshots and pdfs as links that
                                work for 7 days, scrapes as the page url and
                                html at that point, javascriptReturns as the
                                type and value each script returned.
                              type: object
                              additionalProperties: false
                              properties:
                                screenshots:
                                  type: array
                                  items:
                                    type: string
                                    format: uri
                                scrapes:
                                  type: array
                                  items:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      url:
                                        type: string
                                      html:
                                        type: string
                                    required: []
                                javascriptReturns:
                                  type: array
                                  items:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      type:
                                        type: string
                                      value: {}
                                    required: []
                                pdfs:
                                  type: array
                                  items:
                                    type: string
                                    format: uri
                              required: []
                            warning:
                              description: >-
                                Set when an action failed: it names the action
                                and says why. The rest of the answer is the page
                                as it stood before that action.
                              type: string
                            nextOffset:
                              description: >-
                                Where the next part of the text starts, when
                                more follows. Send it as offset, with the same
                                maxChars, to read on.
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            url:
                              type: string
                              format: uri
                            title:
                              type: string
                            description:
                              type: string
                            position:
                              type: integer
                              exclusiveMinimum: 0
                              maximum: 9007199254740991
                            markdown:
                              type: string
                            metadata:
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties:
                                anyOf:
                                  - type: string
                                  - type: number
                                  - type: array
                                    items:
                                      type: string
                            category:
                              description: >-
                                What kind of page this is, when it is one of
                                github, research or pdf.
                              type: string
                              enum:
                                - github
                                - research
                                - pdf
                            date:
                              description: >-
                                When the page was published or last updated,
                                when known.
                              type: string
                          required:
                            - url
                            - position
                      news:
                        type: array
                        items:
                          type: object
                          additionalProperties: false
                          properties:
                            pages:
                              description: >-
                                For a PDF read with the pdf parser and pages
                                true: each page's markdown.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  pageNumber:
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  markdown:
                                    type: string
                                required:
                                  - pageNumber
                            blocks:
                              description: >-
                                For a PDF read with the pdf parser and blocks
                                true: each title, section header or run of text
                                with its page, order, bbox and span.
                              type: array
                              items:
                                type: object
                                propertyNames:
                                  type: string
                                additionalProperties:
                                  $ref: '#/components/schemas/search.schema0'
                            summary:
                              description: A short summary of the page.
                              type: string
                            answer:
                              description: >-
                                The answer to the question format. Left out,
                                with a warning, when the page does not state
                                one.
                              type: string
                            product:
                              description: >-
                                The product the page sells: title, brand,
                                category, url, description and variants, each
                                with its price, sale, availability and images.
                                Left out, with a warning, when the page is not a
                                product page.
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties: {}
                            menu:
                              description: >-
                                The menu on the page: isMenu, confidence,
                                merchant, currency and sections with their
                                items. Left out, with a warning, when the page
                                is not a menu.
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties: {}
                            html:
                              type: string
                            rawHtml:
                              type: string
                            audio:
                              description: >-
                                A link to the audio of a YouTube video as an M4A
                                file. The link works for 1 hour.
                              type: string
                              format: uri
                            video:
                              description: >-
                                A link to a YouTube video as an MP4 file with
                                sound, in the best single-file quality YouTube
                                offers. The link works for 1 hour.
                              type: string
                              format: uri
                            rawBase64:
                              description: >-
                                The bytes the site sent, Base64 encoded, without
                                a data: prefix. metadata.contentType says what
                                they are. Always read live.
                              type: string
                            links:
                              type: array
                              items:
                                type: string
                            images:
                              type: array
                              items:
                                type: string
                            screenshot:
                              description: >-
                                A link to a JPEG of the page. The link works for
                                7 days.
                              type: string
                              format: uri
                            screenshotCropped:
                              description: >-
                                true when the page was taller than the
                                screenshot, so the bottom is cut off.
                              type: boolean
                            highlights:
                              description: >-
                                The passages that best match the highlights
                                query, best first.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  section:
                                    type: string
                                  text:
                                    type: string
                                required: []
                            network:
                              description: >-
                                The JSON responses the page loaded while it
                                rendered, with their bodies.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  url:
                                    type: string
                                  method:
                                    type: string
                                  status:
                                    type: integer
                                    minimum: -9007199254740991
                                    maximum: 9007199254740991
                                  contentType:
                                    type: string
                                  body:
                                    type: string
                                required:
                                  - status
                            branding:
                              description: >-
                                The page's look: colorScheme, logo, colors
                                (hex), fonts, typography, spacing, components,
                                images and layout. Each field is left out or
                                null when the page does not show it.
                              type: object
                              additionalProperties: false
                              properties:
                                colorScheme:
                                  type: string
                                  enum:
                                    - light
                                    - dark
                                logo:
                                  type: string
                                colors:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    primary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    secondary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    accent:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    background:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    textPrimary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    textSecondary:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    link:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    success:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    warning:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                    error:
                                      type: string
                                      pattern: ^#[0-9a-f]{6}$
                                  required: []
                                fonts:
                                  type: array
                                  items:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      family:
                                        type: string
                                        minLength: 1
                                    required:
                                      - family
                                typography:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    fontFamilies:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        primary:
                                          type: string
                                          minLength: 1
                                        heading:
                                          type: string
                                          minLength: 1
                                        code:
                                          type: string
                                          minLength: 1
                                      required: []
                                    fontSizes:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        h1:
                                          type: string
                                          minLength: 1
                                        h2:
                                          type: string
                                          minLength: 1
                                        h3:
                                          type: string
                                          minLength: 1
                                        body:
                                          type: string
                                          minLength: 1
                                      required: []
                                    fontWeights:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        light:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                        regular:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                        medium:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                        bold:
                                          type: integer
                                          minimum: -9007199254740991
                                          maximum: 9007199254740991
                                      required: []
                                    lineHeights:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        heading:
                                          type: string
                                          minLength: 1
                                        body:
                                          type: string
                                          minLength: 1
                                      required: []
                                  required: []
                                spacing:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    baseUnit:
                                      type: integer
                                      minimum: -9007199254740991
                                      maximum: 9007199254740991
                                    borderRadius:
                                      type: string
                                      minLength: 1
                                    padding:
                                      type: object
                                      propertyNames:
                                        type: string
                                      additionalProperties:
                                        type: string
                                        minLength: 1
                                    margins:
                                      type: object
                                      propertyNames:
                                        type: string
                                      additionalProperties:
                                        type: string
                                        minLength: 1
                                  required: []
                                components:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    buttonPrimary:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        background:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        textColor:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        borderRadius:
                                          type: string
                                          minLength: 1
                                      required: []
                                    buttonSecondary:
                                      type: object
                                      additionalProperties: false
                                      properties:
                                        background:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        textColor:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        borderColor:
                                          type: string
                                          pattern: ^#[0-9a-f]{6}$
                                        borderRadius:
                                          type: string
                                          minLength: 1
                                      required: []
                                    input:
                                      type: object
                                      propertyNames:
                                        type: string
                                      additionalProperties:
                                        type: string
                                        minLength: 1
                                  required: []
                                icons:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                images:
                                  type: object
                                  additionalProperties: false
                                  properties:
                                    logo:
                                      type: string
                                    favicon:
                                      type: string
                                    ogImage:
                                      type: string
                                  required: []
                                animations:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                layout:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                personality:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                              required:
                                - colorScheme
                            networkDropped:
                              description: >-
                                How many JSON responses were left out because
                                the page loaded too many or they were too big.
                              type: integer
                              exclusiveMinimum: 0
                              maximum: 9007199254740991
                            json:
                              description: >-
                                What you asked for with the json format. A page
                                from a site Stophy reads natively, such as a
                                Reddit post, comes back as its own data. Any
                                other page comes back as the fields in your
                                schema or prompt, each null when the page does
                                not state it.
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties: {}
                            changeTracking:
                              description: >-
                                new the first time your key reads this page,
                                same when nothing changed, changed with a
                                unified diff of the markdown when something did.
                                With json mode, json holds each field's previous
                                and current value.
                              type: object
                              additionalProperties: false
                              properties:
                                status:
                                  type: string
                                  enum:
                                    - new
                                    - same
                                    - changed
                                previousAt:
                                  type: string
                                  format: date-time
                                  pattern: >-
                                    ^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z))$
                                diff:
                                  type: string
                                json:
                                  type: object
                                  propertyNames:
                                    type: string
                                  additionalProperties:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      previous:
                                        $ref: '#/components/schemas/search.schema0'
                                      current:
                                        $ref: '#/components/schemas/search.schema0'
                                    required: []
                              required:
                                - status
                            attributes:
                              description: >-
                                The values the attributes format read, one entry
                                per selector.
                              type: array
                              items:
                                type: object
                                additionalProperties: false
                                properties:
                                  selector:
                                    type: string
                                  attribute:
                                    type: string
                                  values:
                                    type: array
                                    items:
                                      type: string
                                required: []
                            actions:
                              description: >-
                                What the screenshot, scrape, executeJavascript
                                and pdf actions captured, each in the order the
                                actions ran: screenshots and pdfs as links that
                                work for 7 days, scrapes as the page url and
                                html at that point, javascriptReturns as the
                                type and value each script returned.
                              type: object
                              additionalProperties: false
                              properties:
                                screenshots:
                                  type: array
                                  items:
                                    type: string
                                    format: uri
                                scrapes:
                                  type: array
                                  items:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      url:
                                        type: string
                                      html:
                                        type: string
                                    required: []
                                javascriptReturns:
                                  type: array
                                  items:
                                    type: object
                                    additionalProperties: false
                                    properties:
                                      type:
                                        type: string
                                      value: {}
                                    required: []
                                pdfs:
                                  type: array
                                  items:
                                    type: string
                                    format: uri
                              required: []
                            warning:
                              description: >-
                                Set when an action failed: it names the action
                                and says why. The rest of the answer is the page
                                as it stood before that action.
                              type: string
                            nextOffset:
                              description: >-
                                Where the next part of the text starts, when
                                more follows. Send it as offset, with the same
                                maxChars, to read on.
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            title:
                              type: string
                            url:
                              type: string
                              format: uri
                            snippet:
                              type: string
                            date:
                              type: string
                            imageUrl:
                              type: string
                              format: uri
                            position:
                              type: integer
                              exclusiveMinimum: 0
                              maximum: 9007199254740991
                            markdown:
                              type: string
                            metadata:
                              type: object
                              propertyNames:
                                type: string
                              additionalProperties:
                                anyOf:
                                  - type: string
                                  - type: number
                                  - type: array
                                    items:
                                      type: string
                          required:
                            - url
                            - position
                      images:
                        type: array
                        items:
                          type: object
                          additionalProperties: false
                          properties:
                            title:
                              type: string
                            imageUrl:
                              type: string
                              format: uri
                            imageWidth:
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            imageHeight:
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            url:
                              type: string
                              format: uri
                            position:
                              type: integer
                              exclusiveMinimum: 0
                              maximum: 9007199254740991
                          required:
                            - imageUrl
                            - imageWidth
                            - imageHeight
                            - url
                            - position
                      research:
                        type: array
                        items:
                          type: object
                          additionalProperties: false
                          properties:
                            title:
                              type: string
                            url:
                              type: string
                              format: uri
                              description: >-
                                The paper's DOI link, or its OpenAlex page when
                                it has no DOI.
                            doi:
                              type: string
                            snippet:
                              description: >-
                                The part of the abstract that best matches the
                                query.
                              type: string
                            authors:
                              type: array
                              items:
                                type: string
                              description: Up to the first 10 authors.
                            year:
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            venue:
                              description: The journal, conference or repository.
                              type: string
                            type:
                              description: >-
                                article, preprint, review, book-chapter and so
                                on.
                              type: string
                            citedByCount:
                              type: integer
                              minimum: 0
                              maximum: 9007199254740991
                            openAccessUrl:
                              description: A free copy of the paper, when one exists.
                              type: string
                              format: uri
                            position:
                              type: integer
                              exclusiveMinimum: 0
                              maximum: 9007199254740991
                          required:
                            - url
                            - citedByCount
                            - position
                      videos:
                        type: array
                        items:
                          type: object
                          additionalProperties: false
                          properties:
                            url:
                              type: string
                              format: uri
                              description: >-
                                Watch link. It carries &t= when Stophy knows
                                where in the video the snippet is said.
                            title:
                              type: string
                            channel:
                              type: string
                            channelUrl:
                              type: string
                              format: uri
                            publishedAt:
                              description: >-
                                Approximate: YouTube lists show only how long
                                ago a video was published.
                              type: string
                            durationSeconds:
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            views:
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            snippet:
                              description: >-
                                A passage that matches the query, as spoken,
                                when Stophy holds the captions.
                              type: string
                            startSeconds:
                              description: >-
                                Where the snippet starts, in seconds, when it is
                                known exactly.
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                            position:
                              type: integer
                              minimum: -9007199254740991
                              maximum: 9007199254740991
                          required:
                            - url
                            - position
                    required: []
                  warning:
                    type: string
                required:
                  - success
        4XX:
          $ref: '#/components/responses/Error'
        5XX:
          $ref: '#/components/responses/Error'
      security:
        - apiKey: []
components:
  parameters:
    MaxTextLength:
      name: maxTextLength
      in: query
      required: false
      description: >-
        Cut every text value in the response to this many characters. A value
        that was cut ends with …, and a page whose text was cut has isTruncated
        set to true. A screenshot is never cut. Leave it out to get the full
        text.
      schema:
        type: integer
        minimum: 1
    IdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: >-
        A value you choose for one call. Send the same key with the same method,
        path and body within 24 hours and the first answer comes back with
        idempotent-replayed: true, with the same cost headers and no second
        charge. A call that sends zeroDataRetention and answers with page data
        is not kept, so a retry runs again. Needs an API key.
      schema:
        type: string
  schemas:
    search.input.schema0:
      anyOf:
        - type: string
        - type: number
        - type: boolean
        - type: 'null'
        - type: array
          items:
            $ref: '#/components/schemas/search.input.schema0'
        - type: object
          propertyNames:
            type: string
          additionalProperties:
            $ref: '#/components/schemas/search.input.schema0'
    search.input.schema1:
      anyOf:
        - type: string
        - type: number
        - type: boolean
        - type: 'null'
        - type: array
          items:
            $ref: '#/components/schemas/search.input.schema1'
        - type: object
          propertyNames:
            type: string
          additionalProperties:
            $ref: '#/components/schemas/search.input.schema1'
    search.input.schema2:
      anyOf:
        - type: string
        - type: number
        - type: boolean
        - type: 'null'
        - type: array
          items:
            $ref: '#/components/schemas/search.input.schema2'
        - type: object
          propertyNames:
            type: string
          additionalProperties:
            $ref: '#/components/schemas/search.input.schema2'
    search.schema0:
      anyOf:
        - type: string
        - type: number
        - type: boolean
        - type: 'null'
        - type: array
          items:
            $ref: '#/components/schemas/search.schema0'
        - type: object
          propertyNames:
            type: string
          additionalProperties:
            $ref: '#/components/schemas/search.schema0'
    Error:
      type: object
      required:
        - success
        - error
        - code
      properties:
        success:
          const: false
        error:
          type: string
          description: What went wrong and what to do next.
        code:
          type: string
          enum:
            - apiKeyRequired
            - busy
            - checkRunning
            - cliSessionCompleted
            - cliSessionExists
            - cliSessionNotFound
            - forbidden
            - freeLimit
            - insufficientCredits
            - internalError
            - inviteClaimed
            - inviteDisabled
            - inviteExpired
            - inviteUsedUp
            - invalidCliSession
            - invalidCliVerifier
            - invalidRequest
            - jobFinished
            - methodNotAllowed
            - notFound
            - payloadTooLarge
            - profileBusy
            - profileTooLarge
            - prohibitedPermission
            - promptInjectionDetected
            - rateLimited
            - sourceChanged
            - sourceRefused
            - siteNotRead
            - sourceTimeout
            - sourceUnavailable
            - unauthorized
            - unsupportedMediaType
        retryable:
          type: boolean
          description: true when trying again can help.
        retryAfterSeconds:
          type: integer
        requestId:
          type: string
        requiredCredits:
          type: number
          description: >-
            Older field: the most the call can cost, in $0.002 steps. Sent when
            the balance is too low.
        availableCredits:
          type: number
          description: 'Older field: the balance in $0.002 steps. Sent with requiredCredits.'
        requiredUsd:
          type: number
          description: >-
            The most the call can cost, in dollars. Sent when the balance is too
            low.
        availableUsd:
          type: number
          description: What is left on the account, in dollars. Sent with requiredUsd.
        billingUrl:
          type: string
          description: Where to add money. Sent with requiredUsd.
        signupUrl:
          type: string
          const: https://stophy.dev/signup
          description: >-
            Where a person gets a key. Sent with apiKeyRequired, freeLimit and
            an invalid key.
        signup:
          type: string
          const: POST https://api.stophy.dev/v1/signup
          description: >-
            The call that gets an agent a key with no human. Sent next to
            signupUrl.
  headers:
    RequestId:
      description: The request id. Quote it when you report a problem.
      schema:
        type: string
    CreditsUsed:
      description: >-
        Older header: what this call cost, as whole steps of $0.002. Use
        x-cost-usd.
      schema:
        type: integer
    CostUsd:
      description: What this call cost, in dollars.
      schema:
        type: string
    RateLimitLimit:
      description: Requests allowed in the current window.
      schema:
        type: integer
    RateLimitRemaining:
      description: Requests left in the current window.
      schema:
        type: integer
    RateLimitReset:
      description: Unix time in seconds when the current window resets.
      schema:
        type: integer
    Cache:
      description: hit if this result came from the cache, miss if it was fetched live.
      schema:
        type: string
    CacheAge:
      description: Seconds since the returned result was written to the cache.
      schema:
        type: integer
    IdempotentReplayed:
      description: >-
        true when this call reuses the result of an earlier call with the same
        Idempotency-Key.
      schema:
        type: string
    RetryAfter:
      description: Seconds to wait before retrying.
      schema:
        type: integer
  responses:
    Error:
      description: The request failed. Retry-After says when trying again can help.
      headers:
        X-Request-ID:
          $ref: '#/components/headers/RequestId'
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer

````

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