Copilot API

Request

curl -X POST "https://api.answerline.dev/v1/monitor/copilot" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"Cheapest way to send money abroad","country":"US"}'

Request options

* required. Nested fields are written with a dot, e.g. include.markdown.

What you get back

Full field definitions are in the API reference.

The Copilot answer versus Microsoft’s developer offerings

This endpoint returns the answer the consumer Copilot app gives a user, as text and markdown, with the sources it cites and its citation chips. The searches it ran, product cards and map results are coming.

Developers used to reach Bing results through the Bing Search APIs. Microsoft’s lifecycle notice (checked 2026-09-17, learn.microsoft.com) states those APIs retired on August 11, 2025 and encourages customers to migrate to Grounding with Bing Search as part of Azure AI Agents. Grounding lets your own agent use web data when it generates a response. The answer comes from your model and instructions, not Copilot’s.

For measurement that leaves what only the consumer answer has: Copilot’s own wording (which brands it names, in which order, with which caveats) and the pages it cites for it. Its commercial and local modules and its query fan-out are coming: shoppingCards with structured prices, sellers and ratings, map with businesses, addresses, coordinates, review aggregations and open state, and searchQueries with the web searches Copilot ran. None of the three is returned yet.

An annotated response

The excerpt follows the result schema for POST /v1/monitor/copilot. Values are illustrative.

{
  "success": true,
  "result": {
    "text": "The cheapest option depends on the amount and destination...",
    // Cited pages in order: url and label.
    "sources": [
      {
        "position": 1,
        "url": "https://www.example-finance.com/guides/international-transfer-fees",
        "label": "International transfer fees compared"
      }
    ],
    // One entry per (chip, source) pair; see Copilot sources. Omitted when the answer shows no chips.
    "citationPills": [
      { "citationPillId": 1, "position": 1, "url": "https://www.example-finance.com/guides/international-transfer-fees", "domain": "example-finance.com", "label": "International transfer fees compared" }
    ]
    // searchQueries, shoppingCards and map are coming; not returned yet.
  }
}

Shopping cards and map results are coming; Copilot shopping and map results describes their fields.

Synchronous calls

A synchronous call can take up to five minutes.

Python (requests)

import os
import requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}"}

resp = requests.post(
    f"{API}/v1/monitor/copilot",
    headers=HEADERS,
    json={"prompt": "Cheapest way to send money abroad", "country": "US"},
    timeout=330,
)
if resp.status_code != 200:
    raise RuntimeError(f"{resp.status_code} {resp.headers.get('X-Request-Id')} {resp.text}")

result = resp.json()["result"]
print(result["text"][:200])
for src in result.get("sources", []):
    print(src.get("position"), src.get("url"), src.get("label"))

TypeScript (fetch)

const API = "https://api.answerline.dev";

const res = await fetch(`${API}/v1/monitor/copilot`, {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({ prompt: "Best noise-cancelling headphones under $300", country: "US" }),
  signal: AbortSignal.timeout(330_000),
});
if (!res.ok) throw new Error(`${res.status} ${res.headers.get("X-Request-Id")} ${await res.text()}`);

const { result } = await res.json();
for (const s of result.sources ?? []) {
  console.log(s.position, s.url, s.label);
}
console.log("credits charged:", res.headers.get("X-Credits-Charged"));

Batches: async tasks and a webhook

Tasks cost $0.00274, wait in your queue until they start and post their result to your webhook. POST /v1/async/task/batch takes 1 to 500 tasks, each admitted on its own and answered by index.

Python: submit a batch

import datetime
import os
import requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}"}
day = datetime.date.today().isoformat()

prompts = ["Best credit union for a first mortgage", "Cheapest way to send money abroad"]
tasks = [
    {
        "taskType": "COPILOT",
        "payload": {"prompt": prompt, "country": "US"},
        "idempotencyKey": f"copilot-{i}-US-{day}",
        "webhook": {"url": "https://your-app.example/hooks/answers"},
    }
    for i, prompt in enumerate(prompts)
]

resp = requests.post(f"{API}/v1/async/task/batch", headers=HEADERS, json=tasks, timeout=60)
resp.raise_for_status()
print(resp.json()["summary"])

TypeScript: receive and verify deliveries (Express)

The body is the GET /v1/async/task/{taskId} shape. Verify Webhook-Signature over the raw body before parsing.

import express from "express";
import { createHmac, timingSafeEqual } from "node:crypto";

function verify(raw: Buffer, header: string | undefined, secret: string, toleranceSeconds = 300): boolean {
  const pairs = (header ?? "").split(",").map((part) => part.split("="));
  const stamps = pairs.filter(([k]) => k === "t").map(([, v]) => v);
  const sigs = pairs.filter(([k]) => k === "v1").map(([, v]) => v);
  if (stamps.length !== 1 || !/^\d+$/.test(stamps[0]) || sigs.length === 0) return false;
  if (Math.abs(Date.now() / 1000 - Number(stamps[0])) > toleranceSeconds) return false;
  const expected = createHmac("sha256", secret).update(`${stamps[0]}.`).update(raw).digest();
  return sigs.some((sig) => {
    const given = Buffer.from(sig, "hex");
    return given.length === expected.length && timingSafeEqual(given, expected);
  });
}

const app = express();
app.post("/hooks/answers", express.raw({ type: "application/json" }), (req, res) => {
  if (!verify(req.body, req.get("webhook-signature"), process.env.WEBHOOK_SECRET!)) return res.sendStatus(400);
  const delivery = JSON.parse(req.body.toString("utf8"));
  if (delivery.test) return res.sendStatus(204);
  const { task, response, credits } = delivery;
  if (task.status === "COMPLETED") {
    const { sources = [] } = response.result;
    const domains = [...new Set(sources.map((s: any) => new URL(s.url).hostname))].sort();
    console.log(task.idempotencyKey, domains, credits.creditsCharged);
  } else {
    console.warn(task.idempotencyKey, "failed:", response.error.code);
  }
  res.sendStatus(204);
});
app.listen(3000);

Deliveries can repeat or arrive out of order: deduplicate on task.id. See webhooks.

Geo targeting

Include flags and what they cost

At the Starter tier every Copilot request costs $0.00274.

result.provenance reads searchMode forced: every answer searches the web (all fields).

Common workloads

• AI visibility tracking on Microsoft’s assistant. See AI visibility tracking and monitoring Copilot.
• Citation share: which domains Copilot cites for your category, from sources. See competitor analysis.
• Coming with map, shoppingCards and searchQueries: local presence, product and price monitoring, and keyword discovery from the searches Copilot runs.

Pitfalls

sources depends on the answer and can be empty; default it to an empty list in your code. citationPills is omitted when the answer shows no chips. searchQueries, shoppingCards and map are not returned yet.

Before comparing Copilot with ChatGPT or Google AI Mode, map each engine’s sources to a common record (URL, domain, position).

A large batch is many tasks in your queue, which holds about 100,000 tasks of a typical prompt at a time; there is no concurrency cap and no request rate limit. See rate limits.

Copilot answers differ between runs of the same prompt and market. Take several samples per period and report rates with sample sizes; see AI answer volatility.

How failures are billed

An accepted request reserves its price, $0.00274 on every tier, and is charged only on success. Failures are charged nothing and release the reservation, including tasks that never start within 4 hours (QUEUE_WAIT_EXCEEDED; resubmit them) and queued tasks you delete with DELETE /v1/async/queue. Batch items refused with INSUFFICIENT_CREDITS create nothing and claim no idempotency key, so you can resubmit them unchanged after topping up. See credits.

Related: monitoring Copilot answers and the Copilot API options compared.

Other engines