Microsoft 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 Microsoft Copilot app gives a user, as text and markdown, with the sources it cites. 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.
    "sources": [
      {
        "position": 1,
        "url": "https://www.example-finance.com/guides/international-transfer-fees",
        "label": "International transfer fees compared",
        "description": "Fees and exchange-rate margins for..."
      }
    ]
    // citationPills, 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 costs 54.3 credits, can take up to five minutes, and uses one concurrency slot for its duration.

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 47.3 credits, queue until a slot is free 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

For a design that compares states fairly, see state-level AI answers.

Include flags and what they cost

Every Copilot request costs 47.3 credits as a task and 54.3 synchronously.

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, 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 sharing your concurrency slots with any synchronous calls. Synchronous calls get 429 CONCURRENT_LIMIT_EXCEEDED when every slot is busy; tasks wait. 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 47.3 credits (task) or 54.3 (synchronous) and is charged only on success. Failures are charged nothing and release the reservation, including tasks that never start within 72 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 Microsoft Copilot answers and the Microsoft Copilot API options compared.

Other engines