# FourA Digest — Nov 6 to Nov 13, 2026

> URL: https://foura.ai/blog/foura-digest-2026-11-13
> Updated: 2026-11-13
> Index: https://foura.ai/llms.txt

## Highlights

Plenty of sites set a cookie the moment their check lets a request through, then refuse their own API to anyone who doesn't send it back. Auto now returns that cookie in the session, so the follow-up call to the site's API can run on Single. A failed Auto call also names what the site actually answered, a removed page ends the call in seconds, and Browser completes the verification widget some sites put on their own refusal page.

## What's New

### Auto returns the cookie that opened the page

Some sites guard their data twice. The page loads once a quick check lets your request through, and the JSON behind it (the call the page's own script makes) only answers when you send back the cookie that check set. Auto now returns that cookie in `session.cookies`, so the session that opened the page also opens the API.

Auto's job here is to find the way in once. The follow-up calls belong on Single, through the same proxy ID:

```python
import requests

H = {"X-API-Key": "pk_live_..."}

# 1) Find the route once
r = requests.post(
    "https://api.foura.ai/api/auto",
    headers=H,
    json={"url": "https://example.com/"},
).json()
s = r.get("session") or {}

# 2) Call the site's own API on Single, with the cookie the check set
body = {
    "method": "GET",
    "url": "https://example.com/api/products?page=1",
    "headers": [["Referer", "https://example.com/"]],
}
if s.get("proxy"):
    body["proxy"] = s["proxy"]
if s.get("cookies"):
    body["headers"].append(
        ["Cookie", "; ".join(f"{c['name']}={c['value']}" for c in s["cookies"])]
    )

data = requests.post("https://api.foura.ai/api/single", headers=H, json=body).json()
```

Send the page as `Referer` as well. Many of these APIs refuse a request without it, because the page's own script always sends one. The cookies tend to be short-lived, so when the API starts refusing again, one more Auto call gets you a fresh one. And if you don't know which request the page makes, the DevTools tab of our Chrome extension, still in beta, lists them and copies any one as a ready call (treat a call copied with its cookies like a password, since it can carry a signed-in session). We showed how in [Any Page Request as an API Call](https://foura.ai/blog/chrome-extension-request-to-api-call).

Two smaller changes ride along. A `Cookie` you send to Auto now reaches the site unchanged, and a warm session's cookies are added beside it only under names you didn't send. Your headers also go out on the Single and Proxy Finder requests Auto makes now, including its search for a working exit, while the browser rungs still don't send them. The whole pattern is in [Replaying with the session](https://foura.ai/docs/guides/smart-fetch#replaying-with-the-session).

### A failed Auto call names what the site answered

When Auto can't find a route, you want to know why before you change anything. The `attemptReport` on a failed answer now counts a site that refused the request (a 401, 403, 429 or 503, or a challenge page) under `defense`, even when no bot-check vendor was recognised. A removed page goes under `statusRejected`. The `summary` line names the HTTP status the site sent and says when your daily browser allowance ran out, so no browser could be opened.

Start with `contentRejected`. That count means the page came back and only your own `validate` rule turned it down, which is the one thing you can fix before the job moves to Single or Browser. The rest of the fields are in [Why an Auto call failed](https://foura.ai/docs/guides/smart-fetch#why-an-auto-call-failed).

Removed pages end quickly too. When a site answers `410` for a page it's taken down, Auto ends the call in seconds, even with several of your calls waiting on the same site. If a removed page is a result you want to record, list `404` or `410` in `validate.status.accept`.

### Browser completes a site's own verification step

Some sites answer with their own refusal page, a 401 or 403 with a verification widget on it. Browser with `unblocker: true` now completes the step the widget asks for and waits up to 10 seconds for the page it leads to.

Not every attempt gets through. So when the site still refuses, you get its check page back after the wait, the same answer you got before, and your code doesn't need a new branch.

### Auto spends browser requests where they help

On some sites, the browser requests past the first few in a call rarely bring back the page. Auto now learns that site by site. Where requests past a call's first three almost never work, it keeps to three per call for the next day, works its other routes instead, and then learns again. Your daily browser allowance goes further. Browser requests through premium exits aren't limited, since on a few sites they're the only way in.

When Auto does find a browser route, replay the session it returns on Browser for the volume. That's where production traffic belongs.

On more and more sites the page isn't the data. It's the handshake before the API that holds it, and Auto now hands you both.
