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

# Copilot

> Extract structured data from the Microsoft Copilot web interface - citations and links across five distinct response modes - as clean JSON.

<Info>
  **Five response modes**

  Copilot is the only scraper with switchable response modes. Use `search` for cited web answers, `reasoning` for deep analysis, and `study` for structured educational content.
</Info>

## Overview

Use this endpoint to track brand mentions in Microsoft's AI ecosystem, run structured research across different answer styles, and monitor how Copilot responds to industry queries. The `study` mode is particularly useful for generating structured content briefs.

## Unique features

* **Five modes**: Switch between web search, smart reasoning, chat, deep reasoning, and study-guide formats
* **Named citations**: Cited sources with title and URL via `citations[]`
* **Raw links**: All outbound links surfaced in the response via `links[]`

## Modes

| Mode        | Description                                      |
| ----------- | ------------------------------------------------ |
| `search`    | Web-grounded answer with cited sources (default) |
| `smart`     | Balanced blend of web search and reasoning       |
| `chat`      | Quick direct reply with no web search            |
| `reasoning` | Slower, deeper analysis for complex questions    |
| `study`     | Structured study guide format                    |

## Example request

<CodeGroup>
  ```bash cURL theme={null}
  # Streaming can take up to 300s - --max-time matches the server timeout
  curl --max-time 300 \
    -G "https://api.scrapellm.com/scrapers/copilot" \
    --data-urlencode "api_key=YOUR_API_KEY" \
    --data-urlencode "prompt=What brands do marketers recommend for email automation?" \
    --data-urlencode "country=US" \
    --data-urlencode "mode=search"
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      "https://api.scrapellm.com/scrapers/copilot",
      headers={"X-API-Key": "YOUR_API_KEY"},
      params={
          "prompt": "What brands do marketers recommend for email automation?",
          "country": "US",
          "mode": "search",
      }
  )
  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const params = new URLSearchParams({
    prompt: "What brands do marketers recommend for email automation?",
    country: "US",
    mode: "search",
  });

  const response = await fetch(
    `https://api.scrapellm.com/scrapers/copilot?${params}`,
    { headers: { "X-API-Key": "YOUR_API_KEY" } }
  );
  const data = await response.json();
  ```
</CodeGroup>

## Response schema

Includes [common response fields](/guides/making-requests#common-response-fields) plus:

| Field               | Type    | Description                                      |
| ------------------- | ------- | ------------------------------------------------ |
| `result`            | string  | Plain-text response from Copilot                 |
| `result_markdown`   | string  | Markdown-formatted response                      |
| `mode`              | string  | The mode used for this response                  |
| `citations`         | array   | Named sources cited - each has `title` and `url` |
| `citations[].title` | string  | Article title of the cited source                |
| `citations[].url`   | string  | URL of the cited source                          |
| `links`             | array   | All outbound links surfaced in the response      |
| `credits_used`      | integer | Credits consumed - always `3` for Copilot        |
| `elapsed_ms`        | float   | End-to-end request duration in milliseconds      |
| `cached`            | boolean | `true` if served from cache                      |

## Common questions

### What is the difference between `citations` and `links`?

`citations` are the named sources Copilot explicitly attributes in its answer (with titles). `links` are all outbound URLs surfaced in the response - including links within the answer body that may not be formal citations.

### Which mode is best for brand monitoring?

`search` mode - it's web-grounded and always includes citations, making it the most reliable for tracking which sources Copilot recommends for any industry query.

### When should I use `reasoning` mode?

For complex, multi-part questions where you need analytical depth - competitive analysis, strategy questions, or topics requiring Copilot to weigh multiple factors. Responses take longer but are more thorough.

### Are JP and TW supported?

No. Japan and Taiwan are not currently supported. Use any other ISO 3166-1 alpha-2 country code.


## OpenAPI

````yaml GET /scrapers/copilot
openapi: 3.1.0
info:
  title: ScrapeLLM — Copilot Scraper
  version: 1.0.0
  description: >
    Scrape the real Microsoft Copilot web interface via ScrapeLLM's browser
    pool. Returns the

    full response — including citations and outbound links — as structured JSON,
    across five

    distinct response modes.


    **Base URL:** `https://api.scrapellm.com`


    **Credits:** 3 per request · 500 free credits · No credit card required


    Get your API key at [scrapellm.com/signup](https://scrapellm.com/signup).
  contact:
    email: hello@scrapellm.com
    url: https://scrapellm.com
  license:
    name: ScrapeLLM Terms of Service
    url: https://scrapellm.com/terms
servers:
  - url: https://api.scrapellm.com
    description: Production
security:
  - ApiKeyHeader: []
  - ApiKeyQuery: []
tags:
  - name: Copilot Scraper
    description: Submit prompts to Microsoft Copilot and receive structured responses.
paths:
  /scrapers/copilot:
    get:
      tags:
        - Copilot Scraper
      summary: Send a Copilot Scraping Request
      description: >
        Send a prompt to Microsoft Copilot via a pool of real browsers and get
        the full

        response as structured JSON. Blocks until Copilot responds or `timeout`
        is reached.


        Use the `mode` parameter to control how Copilot responds:

        - **search** — web-grounded answer with cited sources (default)

        - **smart** — balanced blend of web search and reasoning

        - **chat** — quick direct reply, no web search

        - **reasoning** — slower, deeper analysis for complex questions

        - **study** — structured study guide format


        **Country restrictions** — JP and TW are not supported.


        **Authentication** — pass your API key via the `X-API-Key` header or as
        `?api_key=`

        in the URL.
      operationId: scrapeCopilot
      parameters:
        - name: prompt
          in: query
          required: true
          description: The prompt to send to Copilot. Maximum 4,000 characters.
          schema:
            type: string
            minLength: 1
            maxLength: 4000
          example: Best coffee shops in London?
        - name: country
          in: query
          required: false
          description: >
            ISO 3166-1 alpha-2 country code. Routes the request through
            infrastructure in

            that region for localised responses. JP and TW are not supported.
            Defaults to `US`.
          schema:
            type: string
            minLength: 2
            maxLength: 2
            default: US
          example: US
        - name: mode
          in: query
          required: false
          description: |
            Copilot response mode:
            - `search` — web-grounded answer with cited sources (default)
            - `smart` — balanced blend of web search and reasoning
            - `chat` — quick direct reply, no web search
            - `reasoning` — slower, deeper analysis for complex questions
            - `study` — structured study guide format
          schema:
            type: string
            enum:
              - search
              - smart
              - chat
              - reasoning
              - study
            default: search
          example: search
        - name: bypass_cache
          in: query
          required: false
          description: Skip the response cache and always fetch a fresh result.
          schema:
            type: boolean
            default: false
        - name: timeout
          in: query
          required: false
          description: >-
            Maximum seconds to wait for Copilot to respond. Must be between 10
            and 600.
          schema:
            type: number
            format: float
            minimum: 10
            maximum: 600
            default: 300
      responses:
        '200':
          description: Scrape completed successfully.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CopilotScrapeResponse'
              example:
                scraper: copilot
                status: done
                job_id: job_abc123
                prompt: What brands do marketers recommend for email automation?
                country: US
                mode: search
                result: >-
                  Marketers commonly recommend Mailchimp, HubSpot, and
                  Klaviyo...
                result_markdown: >-
                  Marketers commonly recommend **Mailchimp**, **HubSpot**, and
                  **Klaviyo**...
                citations:
                  - title: Best Email Marketing Tools 2025
                    url: https://example.com/email-tools
                  - title: Klaviyo vs Mailchimp Comparison
                    url: https://example.com/comparison
                links:
                  - https://mailchimp.com
                  - https://hubspot.com
                  - https://klaviyo.com
                credits_used: 3
                elapsed_ms: 9102.4
                cached: false
                markdown_url: https://scrapellm.com/md/job_abc123.md
        '401':
          description: Missing or invalid API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                detail: >-
                  Missing API key. Pass your key in the X-API-Key header or as
                  ?api_key= in the URL.
        '429':
          description: Credit limit reached or rate limit exceeded — retry shortly.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Scraper returned an unexpected error — safe to retry.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '502':
          description: Copilot execution failed on the upstream scraper — safe to retry.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '503':
          description: Scraper pool is still warming up — retry in a few seconds.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '504':
          description: Network timeout reaching the scraper machine.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      x-codeSamples:
        - lang: Shell
          label: cURL
          source: >
            # Streaming can take up to 300s - --max-time matches the server
            timeout

            curl --max-time 300 \
              -G "https://api.scrapellm.com/scrapers/copilot" \
              --data-urlencode "api_key=YOUR_API_KEY" \
              --data-urlencode "prompt=What brands do marketers recommend for email automation?" \
              --data-urlencode "country=US" \
              --data-urlencode "mode=search"
        - lang: Python
          label: Python
          source: |
            import requests

            response = requests.get(
                "https://api.scrapellm.com/scrapers/copilot",
                params={
                    "api_key": "YOUR_API_KEY",
                    "prompt": "What brands do marketers recommend for email automation?",
                    "country": "US",
                    "mode": "search",
                }
            )
            print(response.json())
        - lang: JavaScript
          label: JavaScript
          source: |
            const params = new URLSearchParams({
              api_key: "YOUR_API_KEY",
              prompt: "What brands do marketers recommend for email automation?",
              country: "US",
              mode: "search",
            });

            const response = await fetch(
              `https://api.scrapellm.com/scrapers/copilot?${params}`
            );
            const data = await response.json();
            console.log(data);
        - lang: TypeScript
          label: TypeScript
          source: |
            const params = new URLSearchParams({
              api_key: "YOUR_API_KEY",
              prompt: "What brands do marketers recommend for email automation?",
              country: "US",
              mode: "search",
            });

            const response = await fetch(
              `https://api.scrapellm.com/scrapers/copilot?${params}`
            );
            const data = await response.json();
            console.log(data);
components:
  schemas:
    CopilotScrapeResponse:
      type: object
      required:
        - scraper
        - status
        - job_id
        - prompt
        - country
        - mode
        - result
        - credits_used
        - elapsed_ms
        - cached
      properties:
        scraper:
          type: string
          description: Always `"copilot"`.
          example: copilot
        status:
          type: string
          description: '`"done"` on success.'
          example: done
        job_id:
          type: string
          description: Unique identifier for this scrape job.
          example: job_abc123
        prompt:
          type: string
          description: The prompt that was submitted.
          example: What brands do marketers recommend for email automation?
        country:
          type: string
          description: The country the request was routed through.
          example: US
        mode:
          type: string
          description: The Copilot mode used for this request.
          enum:
            - search
            - smart
            - chat
            - reasoning
            - study
          example: search
        result:
          type: string
          description: Plain-text response from Copilot.
          example: Marketers commonly recommend Mailchimp, HubSpot, and Klaviyo...
        result_markdown:
          type: string
          nullable: true
          description: Markdown-formatted response from Copilot.
          example: >-
            Marketers commonly recommend **Mailchimp**, **HubSpot**, and
            **Klaviyo**...
        citations:
          type: array
          description: >-
            Sources explicitly cited by Copilot in its answer, each with a title
            and URL.
          items:
            $ref: '#/components/schemas/CopilotCitation'
        links:
          type: array
          description: All outbound URLs returned by Copilot (superset of `citations`).
          items:
            type: string
            format: uri
          example:
            - https://mailchimp.com
            - https://hubspot.com
        credits_used:
          type: integer
          description: Credits consumed by this request. Always `3` for Copilot.
          example: 3
        elapsed_ms:
          type: number
          format: float
          description: Total end-to-end request duration in milliseconds.
          example: 9102.4
        cached:
          type: boolean
          description: '`true` if this response was served from cache.'
          example: false
        markdown_url:
          type: string
          nullable: true
          description: |
            Hosted `.md` URL for this response. Expires after 24 hours.
          example: https://scrapellm.com/md/job_abc123.md
    ErrorResponse:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          description: Human-readable description of the error.
          example: Invalid API key.
    CopilotCitation:
      type: object
      required:
        - title
        - url
      properties:
        title:
          type: string
          description: Title of the cited page.
          example: Best Email Marketing Tools 2025
        url:
          type: string
          format: uri
          description: Absolute URL of the cited source.
          example: https://example.com/email-tools
  securitySchemes:
    ApiKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
      description: Your ScrapeLLM API key passed in the request header.
    ApiKeyQuery:
      type: apiKey
      in: query
      name: api_key
      description: Your ScrapeLLM API key passed as a query parameter.

````