Why is my agent getting a 403, and what's the legitimate fix?

// npm i robots-parser   (Node 18+)   env: UPROCK_API_KEY// node fetch.ts <url> <country>   country: where the page's readers are, e.g. DEimport { createRequire } from "node:module";​// robots-parser is CommonJS, and its types don't resolve under NodeNext; require() it.const robotsParser: typeof import("robots-parser").default = createRequire(  import.meta.url,)("robots-parser");​// Say who you are and how to reach you, so a site can contact you, not block you.const AGENT = "ExampleAgent/1.0 (+https://example.com/agent)";const TOKEN = "ExampleAgent"; // the name robots.txt groups are matched against​type Result =  | { outcome: "page"; via: "direct" | "uprock"; text: string }  | { outcome: "stop" | "later"; reason: string }; // stop: respect it. later: wait.​const LOGIN_OR_PAYWALL = /\b(sign in|log in|login|subscribe|subscription|paywall)\b/i;const NEEDS_JS =  /enable javascript|requires javascript|javascript is (disabled|required)/i;const REFUSAL = /\b(403|forbidden|access denied)\b/i;​const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));const backoff = (attempt: number) => 2 ** attempt * 1000 + Math.random() * 1000;const visibleText = (html: string) =>  html    .replace(/<(script|style)[\s\S]*?<\/\1>/gi, "")    .replace(/<[^>]+>/g, "")    .trim();​// Retry-After holds either seconds or an HTTP date (RFC 9110, section 10.2.3).function retryAfter(value: string | null): number | undefined {  if (!value) return undefined;  if (/^\d+$/.test(value.trim())) return Number(value) * 1000;  const date = Date.parse(value);  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());}​// RFC 9309: follow the rules; a 4xx means there are none; a 5xx or no answer means// assume everything is disallowed. Don't reuse a copy older than 24 hours.const robotsCache = new Map<  string,  { at: number; robots?: ReturnType<typeof robotsParser> }>();async function robotsCheck(url: string): Promise<"allow" | "disallow" | "unreachable"> {  const robotsUrl = new URL("/robots.txt", url).href;  let entry = robotsCache.get(robotsUrl);  if (!entry || Date.now() - entry.at > 86_400_000) {    try {      const res = await fetch(robotsUrl, {        headers: { "User-Agent": AGENT },        signal: AbortSignal.timeout(15_000),      });      if (res.status >= 500 || res.status === 429) return "unreachable";      const robots = res.ok ? robotsParser(robotsUrl, await res.text()) : undefined;      entry = { at: Date.now(), robots };      robotsCache.set(robotsUrl, entry);    } catch {      return "unreachable";    }  }  return entry.robots?.isAllowed(url, TOKEN) === false ? "disallow" : "allow";}​// A real device in the country the page is meant for. Only for refusals about the// network or the location, and pages that need a browser.async function viaUpRock(url: string, country: string, why: string): Promise<Result> {console.warn(`${why}: trying a real device in ${country} through UpRock`);// One call: UpRock loads the page on a real device in that country, tries a fresh device// every 7 s (up to 3 tries) and returns markdown. Failed calls aren't billed.const res = await fetch("https://edge.uprock.com/v1/crawl", {  method: "POST",  headers: {    Authorization: `Bearer ${process.env.UPROCK_API_KEY}`,    "Content-Type": "application/json",  },  body: JSON.stringify({ url, country }),  signal: AbortSignal.timeout(90_000),});const page = await res.json();if (!res.ok)  return { outcome: "later", reason: `UpRock ${res.status} ${page.code}: ${page.error}` };const text: string = page.markdown ?? "";// The crawl's status_code isn't reliable yet (it can read 0 for a page that loaded), so// read the page: a short page that still says 403 or "forbidden" means the site refuses// everyone. That's its answer.if (text.length < 2_000 && REFUSAL.test(text))  return { outcome: "stop", reason: "a real device got the same refusal" };return { outcome: "page", via: "uprock", text };}​export async function politeFetch(  url: string,  country: string,  tries = 4,): Promise<Result> {  const robots = await robotsCheck(url);  if (robots === "disallow")    return { outcome: "stop", reason: "robots.txt disallows this URL for our agent" };  if (robots === "unreachable")    return { outcome: "later", reason: "robots.txt didn't answer, so assume disallow" };​  for (let attempt = 0; attempt < tries; attempt++) {    let res: Response;    try {      res = await fetch(url, {        headers: { "User-Agent": AGENT },        signal: AbortSignal.timeout(30_000),      });    } catch (err) {      if (attempt === 0) {        await sleep(backoff(0)); // one retry from here first        continue;      }      return viaUpRock(url, country, `no answer from this network (${err})`);    }    const status = res.status;    const body = await res.text();​    if (res.ok) {      if (NEEDS_JS.test(body) && visibleText(body).length < 500)        return viaUpRock(url, country, "the page is built with JavaScript");      return { outcome: "page", via: "direct", text: body };    }    if (status === 429 || status >= 500) {      // Too fast or overloaded: wait as asked. Another network won't fix it.      const wait = retryAfter(res.headers.get("retry-after")) ?? backoff(attempt);      if (attempt === tries - 1 || wait > 120_000)        return {          outcome: "later",          reason: `${status}, wait ${Math.ceil(wait / 1000)} s`,        };      console.warn(`${status}: waiting ${Math.ceil(wait / 1000)} s`);      await sleep(wait);      continue;    }    if (status === 401 || status === 402)      return { outcome: "stop", reason: `${status}: needs an account or payment` };    if (status === 404 || status === 410)      return { outcome: "stop", reason: `${status}: the page doesn't exist` };    if (status === 451)      return { outcome: "stop", reason: "451: unavailable for legal reasons" };    if (status === 403) {      if (LOGIN_OR_PAYWALL.test(visibleText(body)))        return { outcome: "stop", reason: "403: needs an account or a subscription" };      return viaUpRock(url, country, "403 from this network");    }    return { outcome: "stop", reason: `HTTP ${status}` };  }  return { outcome: "later", reason: "no answer after retries" };}​// node fetch.ts https://developer.mozilla.org/en-US/docs/Web/HTTP DEconst [url = "https://developer.mozilla.org/en-US/docs/Web/HTTP", country = "US"] =  process.argv.slice(2);const result = await politeFetch(url, country);const preview = (text: string) => text.slice(0, 80).replace(/\s+/g, " ").trim();console.log(  result.outcome === "page"    ? `page via ${result.via}: ${preview(result.text)}`    : `${result.outcome}: ${result.reason}`,);

# pip install requests protego   env: UPROCK_API_KEY# python fetch.py <url> <country>   country: where the page's readers are, e.g. DEimport osimport randomimport reimport sysimport timefrom email.utils import parsedate_to_datetimefrom urllib.parse import urljoin​import requestsfrom protego import Protego​# Say who you are and how to reach you, so a site can contact you, not block you.AGENT = "ExampleAgent/1.0 (+https://example.com/agent)"TOKEN = "ExampleAgent"  # the name robots.txt groups are matched against​LOGIN_OR_PAYWALL = re.compile(    r"\b(sign in|log in|login|subscribe|subscription|paywall)\b", re.IGNORECASE)NEEDS_JS = re.compile(    r"enable javascript|requires javascript|javascript is (disabled|required)",    re.IGNORECASE,)REFUSAL = re.compile(r"\b(403|forbidden|access denied)\b", re.IGNORECASE)​​def backoff(attempt: int) -> float:    return 2**attempt + random.random()​​def visible_text(html: str) -> str:    html = re.sub(r"<(script|style)[\s\S]*?</\1>", "", html, flags=re.IGNORECASE)    return re.sub(r"<[^>]+>", "", html).strip()​​def retry_after(value: str | None) -> float | None:    """Retry-After holds either seconds or an HTTP date (RFC 9110, section 10.2.3)."""    if not value:        return None    if value.strip().isdigit():        return float(value)    try:        return max(0.0, parsedate_to_datetime(value).timestamp() - time.time())    except (TypeError, ValueError):        return None​​# RFC 9309: follow the rules; a 4xx means there are none; a 5xx or no answer means# assume everything is disallowed. Don't reuse a copy older than 24 hours._robots: dict[str, tuple[float, Protego | None]] = {}​​def robots_check(url: str) -> str:    robots_url = urljoin(url, "/robots.txt")    entry = _robots.get(robots_url)    if entry is None or time.time() - entry[0] > 86_400:        try:            res = requests.get(robots_url, headers={"User-Agent": AGENT}, timeout=15)        except requests.RequestException:            return "unreachable"        if res.status_code >= 500 or res.status_code == 429:            return "unreachable"        entry = (time.time(), Protego.parse(res.text) if res.ok else None)        _robots[robots_url] = entry    robots = entry[1]    return "allow" if robots is None or robots.can_fetch(url, TOKEN) else "disallow"​​def via_uprock(url: str, country: str, why: str) -> dict:    """A real device in the country the page is meant for. Only for refusals about    the network or the location, and pages that need a browser."""    print(f"{why}: trying a real device in {country} through UpRock", file=sys.stderr)    # One call: UpRock loads the page on a real device in that country, tries a fresh device    # every 7 s (up to 3 tries) and returns markdown. Failed calls aren't billed.    res = requests.post(        "https://edge.uprock.com/v1/crawl",        headers={"Authorization": f"Bearer {os.environ['UPROCK_API_KEY']}"},        json={"url": url, "country": country},        timeout=90,    )    page = res.json()    if not res.ok:        return {"outcome": "later", "reason": f"UpRock {res.status_code} {page.get('code')}: {page.get('error')}"}    text = page.get("markdown", "")    # The crawl's status_code isn't reliable yet (it can read 0 for a page that loaded), so    # read the page: a short page that still says 403 or "forbidden" means the site refuses    # everyone. That's its answer.    if len(text) < 2_000 and REFUSAL.search(text):        return {"outcome": "stop", "reason": "a real device got the same refusal"}    return {"outcome": "page", "via": "uprock", "text": text}​​def polite_fetch(url: str, country: str, tries: int = 4) -> dict:    robots = robots_check(url)    if robots == "disallow":        return {            "outcome": "stop",            "reason": "robots.txt disallows this URL for our agent",        }    if robots == "unreachable":        return {            "outcome": "later",            "reason": "robots.txt didn't answer, so assume disallow",        }​    for attempt in range(tries):        try:            res = requests.get(url, headers={"User-Agent": AGENT}, timeout=30)        except requests.RequestException as err:            if attempt == 0:                time.sleep(backoff(0))  # one retry from here first                continue            return via_uprock(url, country, f"no answer from this network ({err})")        status = res.status_code​        if res.ok:            if NEEDS_JS.search(res.text) and len(visible_text(res.text)) < 500:                return via_uprock(url, country, "the page is built with JavaScript")            return {"outcome": "page", "via": "direct", "text": res.text}        if status == 429 or status >= 500:            # Too fast or overloaded: wait as asked. Another network won't fix it.            wait = retry_after(res.headers.get("Retry-After")) or backoff(attempt)            if attempt == tries - 1 or wait > 120:                return {"outcome": "later", "reason": f"{status}, wait {wait:.0f} s"}            print(f"{status}: waiting {wait:.0f} s", file=sys.stderr)            time.sleep(wait)            continue        if status in (401, 402):            return {                "outcome": "stop",                "reason": f"{status}: needs an account or payment",            }        if status in (404, 410):            return {"outcome": "stop", "reason": f"{status}: the page doesn't exist"}        if status == 451:            return {"outcome": "stop", "reason": "451: unavailable for legal reasons"}        if status == 403:            if LOGIN_OR_PAYWALL.search(visible_text(res.text)):                return {                    "outcome": "stop",                    "reason": "403: needs an account or a subscription",                }            return via_uprock(url, country, "403 from this network")        return {"outcome": "stop", "reason": f"HTTP {status}"}    return {"outcome": "later", "reason": "no answer after retries"}​​if __name__ == "__main__":    # python fetch.py https://developer.mozilla.org/en-US/docs/Web/HTTP DE    url = sys.argv[1] if len(sys.argv) > 1 else "https://developer.mozilla.org/en-US/docs/Web/HTTP"    country = sys.argv[2] if len(sys.argv) > 2 else "US"    result = polite_fetch(url, country)    if result["outcome"] == "page":        print(f"page via {result['via']}: {' '.join(result['text'][:80].split())}")    else:        print(f"{result['outcome']}: {result['reason']}")

// npm i robots-parser @modelcontextprotocol/sdk   (Node 18+)   env: UPROCK_API_KEY// node fetch.ts <url> <country>   country: where the page's readers are, e.g. DEimport { createRequire } from "node:module";import { Client } from "@modelcontextprotocol/sdk/client/index.js";import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";​// robots-parser is CommonJS, and its types don't resolve under NodeNext; require() it.const robotsParser: typeof import("robots-parser").default = createRequire(  import.meta.url,)("robots-parser");​// Say who you are and how to reach you, so a site can contact you, not block you.const AGENT = "ExampleAgent/1.0 (+https://example.com/agent)";const TOKEN = "ExampleAgent"; // the name robots.txt groups are matched against​type Result =  | { outcome: "page"; via: "direct" | "uprock"; text: string }  | { outcome: "stop" | "later"; reason: string }; // stop: respect it. later: wait.​const LOGIN_OR_PAYWALL = /\b(sign in|log in|login|subscribe|subscription|paywall)\b/i;const NEEDS_JS =  /enable javascript|requires javascript|javascript is (disabled|required)/i;const REFUSAL = /\b(403|forbidden|access denied)\b/i;​const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));const backoff = (attempt: number) => 2 ** attempt * 1000 + Math.random() * 1000;const visibleText = (html: string) =>  html    .replace(/<(script|style)[\s\S]*?<\/\1>/gi, "")    .replace(/<[^>]+>/g, "")    .trim();​// Retry-After holds either seconds or an HTTP date (RFC 9110, section 10.2.3).function retryAfter(value: string | null): number | undefined {  if (!value) return undefined;  if (/^\d+$/.test(value.trim())) return Number(value) * 1000;  const date = Date.parse(value);  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());}​// RFC 9309: follow the rules; a 4xx means there are none; a 5xx or no answer means// assume everything is disallowed. Don't reuse a copy older than 24 hours.const robotsCache = new Map<  string,  { at: number; robots?: ReturnType<typeof robotsParser> }>();async function robotsCheck(url: string): Promise<"allow" | "disallow" | "unreachable"> {  const robotsUrl = new URL("/robots.txt", url).href;  let entry = robotsCache.get(robotsUrl);  if (!entry || Date.now() - entry.at > 86_400_000) {    try {      const res = await fetch(robotsUrl, {        headers: { "User-Agent": AGENT },        signal: AbortSignal.timeout(15_000),      });      if (res.status >= 500 || res.status === 429) return "unreachable";      const robots = res.ok ? robotsParser(robotsUrl, await res.text()) : undefined;      entry = { at: Date.now(), robots };      robotsCache.set(robotsUrl, entry);    } catch {      return "unreachable";    }  }  return entry.robots?.isAllowed(url, TOKEN) === false ? "disallow" : "allow";}​let uprock: Client | undefined;const textOf = (content: unknown) =>  (content as { type: string; text?: string }[]).find((c) => c.type === "text")?.text ??  "";​// A real device in the country the page is meant for. Only for refusals about the// network or the location, and pages that need a browser.async function viaUpRock(url: string, country: string, why: string): Promise<Result> {  console.warn(`${why}: trying a real device in ${country} through UpRock`);  if (!uprock) {    uprock = new Client({ name: "polite-fetch", version: "1.0.0" });    await uprock.connect(      new StreamableHTTPClientTransport(        new URL("https://mcp.uprock.ai/mcp"),        { requestInit: { headers: { Authorization: `Bearer ${process.env.UPROCK_API_KEY}` } } },      ),    );  }  const res = await uprock.callTool(    { name: "crawl_fetch", arguments: { url, country } },    undefined,    { timeout: 300_000 },  );  if (res.isError)    return { outcome: "later", reason: `UpRock: ${textOf(res.content)}` };  const uri = JSON.parse(textOf(res.content)).content?.markdown?.resource;  if (!uri) return { outcome: "later", reason: "UpRock returned no markdown" };  const text = textOf(    (await uprock.callTool({ name: "resource_fetch", arguments: { uri } })).content,  );  // crawl_fetch's status code isn't reliable yet, so read the page: a short page that  // still says 403 or "forbidden" means the site refuses everyone. That's its answer.  if (text.length < 2_000 && REFUSAL.test(text))    return { outcome: "stop", reason: "a real device got the same refusal" };  return { outcome: "page", via: "uprock", text };}​export async function politeFetch(  url: string,  country: string,  tries = 4,): Promise<Result> {  const robots = await robotsCheck(url);  if (robots === "disallow")    return { outcome: "stop", reason: "robots.txt disallows this URL for our agent" };  if (robots === "unreachable")    return { outcome: "later", reason: "robots.txt didn't answer, so assume disallow" };​  for (let attempt = 0; attempt < tries; attempt++) {    let res: Response;    try {      res = await fetch(url, {        headers: { "User-Agent": AGENT },        signal: AbortSignal.timeout(30_000),      });    } catch (err) {      if (attempt === 0) {        await sleep(backoff(0)); // one retry from here first        continue;      }      return viaUpRock(url, country, `no answer from this network (${err})`);    }    const status = res.status;    const body = await res.text();​    if (res.ok) {      if (NEEDS_JS.test(body) && visibleText(body).length < 500)        return viaUpRock(url, country, "the page is built with JavaScript");      return { outcome: "page", via: "direct", text: body };    }    if (status === 429 || status >= 500) {      // Too fast or overloaded: wait as asked. Another network won't fix it.      const wait = retryAfter(res.headers.get("retry-after")) ?? backoff(attempt);      if (attempt === tries - 1 || wait > 120_000)        return {          outcome: "later",          reason: `${status}, wait ${Math.ceil(wait / 1000)} s`,        };      console.warn(`${status}: waiting ${Math.ceil(wait / 1000)} s`);      await sleep(wait);      continue;    }    if (status === 401 || status === 402)      return { outcome: "stop", reason: `${status}: needs an account or payment` };    if (status === 404 || status === 410)      return { outcome: "stop", reason: `${status}: the page doesn't exist` };    if (status === 451)      return { outcome: "stop", reason: "451: unavailable for legal reasons" };    if (status === 403) {      if (LOGIN_OR_PAYWALL.test(visibleText(body)))        return { outcome: "stop", reason: "403: needs an account or a subscription" };      return viaUpRock(url, country, "403 from this network");    }    return { outcome: "stop", reason: `HTTP ${status}` };  }  return { outcome: "later", reason: "no answer after retries" };}​// node fetch.ts https://developer.mozilla.org/en-US/docs/Web/HTTP DEconst [url = "https://developer.mozilla.org/en-US/docs/Web/HTTP", country = "US"] =  process.argv.slice(2);try {  const result = await politeFetch(url, country);  const preview = (text: string) => text.slice(0, 80).replace(/\s+/g, " ").trim();  console.log(    result.outcome === "page"      ? `page via ${result.via}: ${preview(result.text)}`      : `${result.outcome}: ${result.reason}`,  );} finally {  await uprock?.close();}

# pip install requests protego; npm i -g uprock   env: UPROCK_API_KEY# python fetch.py <url> <country>   country: where the page's readers are, e.g. DEimport jsonimport randomimport reimport subprocessimport sysimport timefrom email.utils import parsedate_to_datetimefrom urllib.parse import urljoin​import requestsfrom protego import Protego​# Say who you are and how to reach you, so a site can contact you, not block you.AGENT = "ExampleAgent/1.0 (+https://example.com/agent)"TOKEN = "ExampleAgent"  # the name robots.txt groups are matched against​LOGIN_OR_PAYWALL = re.compile(    r"\b(sign in|log in|login|subscribe|subscription|paywall)\b", re.IGNORECASE)NEEDS_JS = re.compile(    r"enable javascript|requires javascript|javascript is (disabled|required)",    re.IGNORECASE,)REFUSAL = re.compile(r"\b(403|forbidden|access denied)\b", re.IGNORECASE)​​def backoff(attempt: int) -> float:    return 2**attempt + random.random()​​def visible_text(html: str) -> str:    html = re.sub(r"<(script|style)[\s\S]*?</\1>", "", html, flags=re.IGNORECASE)    return re.sub(r"<[^>]+>", "", html).strip()​​def retry_after(value: str | None) -> float | None:    """Retry-After holds either seconds or an HTTP date (RFC 9110, section 10.2.3)."""    if not value:        return None    if value.strip().isdigit():        return float(value)    try:        return max(0.0, parsedate_to_datetime(value).timestamp() - time.time())    except (TypeError, ValueError):        return None​​# RFC 9309: follow the rules; a 4xx means there are none; a 5xx or no answer means# assume everything is disallowed. Don't reuse a copy older than 24 hours._robots: dict[str, tuple[float, Protego | None]] = {}​​def robots_check(url: str) -> str:    robots_url = urljoin(url, "/robots.txt")    entry = _robots.get(robots_url)    if entry is None or time.time() - entry[0] > 86_400:        try:            res = requests.get(robots_url, headers={"User-Agent": AGENT}, timeout=15)        except requests.RequestException:            return "unreachable"        if res.status_code >= 500 or res.status_code == 429:            return "unreachable"        entry = (time.time(), Protego.parse(res.text) if res.ok else None)        _robots[robots_url] = entry    robots = entry[1]    return "allow" if robots is None or robots.can_fetch(url, TOKEN) else "disallow"​​def via_uprock(url: str, country: str, why: str) -> dict:    """A real device in the country the page is meant for. Only for refusals about    the network or the location, and pages that need a browser."""    print(f"{why}: trying a real device in {country} through UpRock", file=sys.stderr)    run = subprocess.run(        ["uprock", "ai", "crawl", url, "--country", country, "--content"],        capture_output=True,        text=True,        timeout=330,        check=False,    )    if run.returncode != 0:        return {"outcome": "later", "reason": f"UpRock: {run.stderr.strip()}"}    text = json.loads(run.stdout).get("inlined_markdown", "")    # The crawl's status code isn't reliable yet, so read the page: a short page that    # still says 403 or "forbidden" means the site refuses everyone. That's its answer.    if len(text) < 2_000 and REFUSAL.search(text):        return {"outcome": "stop", "reason": "a real device got the same refusal"}    return {"outcome": "page", "via": "uprock", "text": text}​​def polite_fetch(url: str, country: str, tries: int = 4) -> dict:    robots = robots_check(url)    if robots == "disallow":        return {            "outcome": "stop",            "reason": "robots.txt disallows this URL for our agent",        }    if robots == "unreachable":        return {            "outcome": "later",            "reason": "robots.txt didn't answer, so assume disallow",        }​    for attempt in range(tries):        try:            res = requests.get(url, headers={"User-Agent": AGENT}, timeout=30)        except requests.RequestException as err:            if attempt == 0:                time.sleep(backoff(0))  # one retry from here first                continue            return via_uprock(url, country, f"no answer from this network ({err})")        status = res.status_code​        if res.ok:            if NEEDS_JS.search(res.text) and len(visible_text(res.text)) < 500:                return via_uprock(url, country, "the page is built with JavaScript")            return {"outcome": "page", "via": "direct", "text": res.text}        if status == 429 or status >= 500:            # Too fast or overloaded: wait as asked. Another network won't fix it.            wait = retry_after(res.headers.get("Retry-After")) or backoff(attempt)            if attempt == tries - 1 or wait > 120:                return {"outcome": "later", "reason": f"{status}, wait {wait:.0f} s"}            print(f"{status}: waiting {wait:.0f} s", file=sys.stderr)            time.sleep(wait)            continue        if status in (401, 402):            return {                "outcome": "stop",                "reason": f"{status}: needs an account or payment",            }        if status in (404, 410):            return {"outcome": "stop", "reason": f"{status}: the page doesn't exist"}        if status == 451:            return {"outcome": "stop", "reason": "451: unavailable for legal reasons"}        if status == 403:            if LOGIN_OR_PAYWALL.search(visible_text(res.text)):                return {                    "outcome": "stop",                    "reason": "403: needs an account or a subscription",                }            return via_uprock(url, country, "403 from this network")        return {"outcome": "stop", "reason": f"HTTP {status}"}    return {"outcome": "later", "reason": "no answer after retries"}​​if __name__ == "__main__":    # python fetch.py https://developer.mozilla.org/en-US/docs/Web/HTTP DE    url = sys.argv[1] if len(sys.argv) > 1 else "https://developer.mozilla.org/en-US/docs/Web/HTTP"    country = sys.argv[2] if len(sys.argv) > 2 else "US"    result = polite_fetch(url, country)    if result["outcome"] == "page":        print(f"page via {result['via']}: {' '.join(result['text'][:80].split())}")    else:        print(f"{result['outcome']}: {result['reason']}")