diff --git a/datasets/amfv_datasets/scraping/__init__.py b/datasets/amfv_datasets/scraping/__init__.py
index cd7cdb0..d5630df 100644
--- a/datasets/amfv_datasets/scraping/__init__.py
+++ b/datasets/amfv_datasets/scraping/__init__.py
@@ -27,6 +27,16 @@
     scrape_guideline,
     scrape_nice,
 )
+from amfv_datasets.scraping.pubmed import (
+    PubMedArticleRef,
+    PubMedFetchError,
+    PubMedListingPage,
+    build_pubmed_article_text,
+    list_pubmed_guidelines,
+    pubmed_ref_from_url,
+    scrape_pubmed,
+    scrape_pubmed_article,
+)
 
 __all__ = [
     "GuidanceRef",
@@ -34,6 +44,9 @@
     "LinkMode",
     "NiceFetchError",
     "OutputFormat",
+    "PubMedArticleRef",
+    "PubMedFetchError",
+    "PubMedListingPage",
     "ScrapeError",
     "ScrapeRun",
     "ScrapedDocument",
@@ -41,6 +54,7 @@
     "USER_AGENT",
     "absolute_unique_urls",
     "build_guideline_text",
+    "build_pubmed_article_text",
     "clean_text",
     "document_title",
     "default_client",
@@ -48,7 +62,11 @@
     "guidance_ref_from_url",
     "html_to_markdown",
     "list_published_guidance",
+    "list_pubmed_guidelines",
+    "pubmed_ref_from_url",
     "scrape_guideline",
     "scrape_listing_documents",
     "scrape_nice",
+    "scrape_pubmed",
+    "scrape_pubmed_article",
 ]
diff --git a/datasets/amfv_datasets/scraping/base.py b/datasets/amfv_datasets/scraping/base.py
index 0708ee8..3651cdb 100644
--- a/datasets/amfv_datasets/scraping/base.py
+++ b/datasets/amfv_datasets/scraping/base.py
@@ -74,7 +74,7 @@ def scrape_listing_documents[ListingItemT](
     documents: int | None,
     client_factory: Callable[[], AbstractContextManager[httpx.Client]],
     list_page: Callable[[httpx.Client, int], Iterable[ListingItemT]],
-    scrape_item: Callable[[httpx.Client, ListingItemT], ScrapedDocument],
+    scrape_item: Callable[[httpx.Client, ListingItemT], ScrapedDocument | None],
     document_delay_seconds: float = 5.0,
     first_page_items: Iterable[ListingItemT] | None = None,
 ) -> Iterable[ScrapedDocument]:
@@ -85,7 +85,8 @@ def scrape_listing_documents[ListingItemT](
             fetched until a page returns no items (default: None).
         client_factory: Factory returning a context-managed HTTP client.
         list_page: Function that lists source-specific items for a page.
-        scrape_item: Function that scrapes one listed item into a document.
+        scrape_item: Function that scrapes one listed item into a document. It
+            may return None to skip a discovered item that is not a document.
         document_delay_seconds: Delay before scraping each document after the
             first one (default: 5.0).
         first_page_items: Already-fetched first listing page items. When set,
@@ -99,6 +100,7 @@ def scrape_listing_documents[ListingItemT](
     with client_factory() as client:
         page = 1
         scraped = 0
+        attempted = 0
         page_items = list(first_page_items) if first_page_items is not None else None
         while documents is None or scraped < documents:
             if page_items is None:
@@ -111,9 +113,13 @@ def scrape_listing_documents[ListingItemT](
             for item in items:
                 if documents is not None and scraped >= documents:
                     break
-                if scraped and document_delay_seconds:
+                if attempted and document_delay_seconds:
                     time.sleep(document_delay_seconds)
-                yield scrape_item(client, item)
+                document = scrape_item(client, item)
+                attempted += 1
+                if document is None:
+                    continue
+                yield document
                 scraped += 1
             page += 1
 
diff --git a/datasets/amfv_datasets/scraping/cli.py b/datasets/amfv_datasets/scraping/cli.py
index e8aece3..32cafb1 100644
--- a/datasets/amfv_datasets/scraping/cli.py
+++ b/datasets/amfv_datasets/scraping/cli.py
@@ -27,6 +27,7 @@
 from amfv_datasets.scraping.base import ScrapedDocument, ScrapeRun
 from amfv_datasets.scraping.html import LinkMode
 from amfv_datasets.scraping.nice import scrape_nice
+from amfv_datasets.scraping.pubmed import scrape_pubmed
 
 
 class ScraperSource(StrEnum):
@@ -34,6 +35,7 @@ class ScraperSource(StrEnum):
 
     ALL = "all"
     NICE = "nice"
+    PUBMED = "pubmed"
 
 
 class OutputFormat(StrEnum):
@@ -72,6 +74,8 @@ def scrape_documents(
         match selected_source:
             case ScraperSource.NICE:
                 return scrape_nice(documents=documents, link_mode=link_mode, url=url)
+            case ScraperSource.PUBMED:
+                return scrape_pubmed(documents=documents, link_mode=link_mode, url=url)
             case ScraperSource.ALL:
                 raise AssertionError("expanded source cannot be all")
     raise AssertionError(f"unsupported source: {source}")
@@ -125,7 +129,7 @@ def write_markdown_files(documents: Iterable[ScrapedDocument], output_path: Path
 
 def _expand_source(source: ScraperSource) -> tuple[ScraperSource, ...]:
     if source is ScraperSource.ALL:
-        return (ScraperSource.NICE,)
+        return (ScraperSource.NICE, ScraperSource.PUBMED)
     return (source,)
 
 
diff --git a/datasets/amfv_datasets/scraping/pubmed.py b/datasets/amfv_datasets/scraping/pubmed.py
new file mode 100644
index 0000000..5a1f411
--- /dev/null
+++ b/datasets/amfv_datasets/scraping/pubmed.py
@@ -0,0 +1,723 @@
+"""Scrape PubMed clinical practice guidelines into normalized markdown documents.
+
+PubMed indexes roughly 43k articles tagged with the `Guideline` publication
+type, but most of them expose an abstract only and stay under publisher
+copyright. This module deliberately scrapes the intersection with the PMC Open
+Access subset instead:
+
+    Guideline[pt] AND pubmed pmc open access[filter] AND English[la]
+
+That is about 3,000 guidelines, growing by a handful a week, and it is the only
+slice where the full text is both retrievable and openly licensed.
+
+Licensing is recorded per document rather than claimed for the source, because
+the Open Access Subset is not uniformly Creative Commons licensed. Censused
+over all 2,999 records present on 2026-07-29: CC BY 44.5%, CC BY-NC 22.1%,
+CC BY-NC-ND 18.4%, CC BY-NC-SA 2.1%, CC0 1.3%, and 11.7% carrying publisher
+terms instead. By what that permits, 45.8% is unrestricted for derivative
+works, 24.1% is non-commercial only, 18.4% asserts NoDerivatives, and 11.7%
+has to be read case by case.
+
+Discovery and extraction both go through NCBI's E-utilities rather than the
+rendered pubmed.ncbi.nlm.nih.gov pages. `esearch` paginates by numeric offset and
+reports the result total, `esummary` resolves a whole batch of PMIDs to PMCIDs
+and citation metadata in one request, and `efetch` returns JATS XML carrying the
+article body, section structure and license. All three are documented, versioned
+contracts that do not break when the website is restyled.
+
+Attribution:
+Meditron's guideline scrapers (epfLLM/meditron, gap-replay/guidelines) cover a
+dozen sources but have no PubMed scraper, so this module has no upstream port to
+follow. It follows the conventions of `nice.py` in this package instead.
+Source license: Apache License 2.0.
+"""
+
+from __future__ import annotations
+
+import copy
+import logging
+import os
+import re
+import time
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+from lxml import etree
+
+from amfv_datasets.scraping.base import (
+    ScrapedDocument,
+    ScrapeError,
+    ScrapeRun,
+    default_client,
+    scrape_listing_documents,
+)
+from amfv_datasets.scraping.html import LinkMode, clean_text, html_to_markdown
+
+BASE_URL = "https://pubmed.ncbi.nlm.nih.gov"
+EUTILS_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+PMC_ARTICLE_URL = "https://www.ncbi.nlm.nih.gov/pmc/articles"
+# `Guideline` is a strict superset of `Practice Guideline`: searching for either
+# returns exactly the `Guideline` count. The 352 extra records are clinical, not
+# administrative — the 2025 Korean CPR guidelines and similar — so scoping to
+# `Practice Guideline` would drop 352 records (11%) for nothing.
+#
+# `English[la]` drops 185 records. Most other sources in this package are
+# English-only as a side effect of the URL they start from (CPS is a bilingual
+# site scraped through its `/en/` routes; WHO publishes in six languages and is
+# scraped through its English listing). PubMed's API returns every language, so
+# the filter is explicit here to match. The excluded records are largely French
+# CMAJ translations of English guidelines already in the corpus.
+SEARCH_TERM = "Guideline[pt] AND pubmed pmc open access[filter] AND English[la]"
+PUBMED_DATASET_NAME = "pubmed-webscrape"
+PUBMED_DATASET_DISPLAY_NAME = "PubMed Webscrape"
+NCBI_TOOL = "amfv"
+# NCBI documents 3 requests/second without an API key and 10 with one, so unlike
+# a scraped website this delay is a published allowance rather than a guess. Do
+# not raise it to match the other scrapers "for consistency" — that turns a
+# 20-minute run into a 4-hour one for no benefit.
+DOCUMENT_DELAY_SECONDS = 0.4
+LISTING_PAGE_SIZE = 200
+# Enough of a non-CC license statement to tell "unrestricted re-use" apart from
+# "all rights reserved" without carrying a wall of boilerplate per document.
+_LICENSE_STATEMENT_CHARS = 400
+_FIGURE_CAPTION_CHARS = 300
+# NCBI answers a burst with 429 and is transiently unavailable often enough that
+# a multi-thousand document run needs to ride both out.
+_MAX_RETRIES = 4
+_RETRY_BACKOFF_SECONDS = 1.0
+_RETRYABLE_STATUS = frozenset({429, 500, 502, 503, 504})
+
+logger = logging.getLogger(__name__)
+
+_PUBMED_PATH_RE = re.compile(r"^/(?P<pmid>\d+)/?$")
+_PMC_PATH_RE = re.compile(r"^/pmc/articles/(?P<pmcid>PMC\d+)/?$", re.IGNORECASE)
+_CC_URL_RE = re.compile(r"https?://creativecommons\.org/\S+?(?=[\s\"<)]|$)")
+# Unwrapping `xref` and dropping figures leaves the surrounding spacing behind,
+# as in "(PRISMA flow diagram in Supplementary Fig. S1) ." — close it back up.
+_ORPHAN_SPACE_RE = re.compile(r" +([,.;:)\]])")
+_XLINK_HREF = "{http://www.w3.org/1999/xlink}href"
+_ALI_LICENSE_REF = "{http://www.niso.org/schemas/ali/1.0/}license_ref"
+
+# JATS elements whose entire subtree is dropped. Reference lists and footnote
+# groups are citation apparatus rather than clinical content. Figure payloads
+# cannot be linked from the API response at all (see `_article_figures`), so the
+# `<graphic>` goes but its `<label>` and `<caption>` stay in the text, and the
+# filename is recorded in `metadata.figures` for a later pass to resolve.
+_DROPPED_TAGS = (
+    "ref-list",
+    "fn-group",
+    "supplementary-material",
+    "table-wrap-foot",
+    "graphic",
+    "inline-graphic",
+    "media",
+    "object-id",
+    "alt-text",
+)
+# Elements unwrapped to their text. `xref` is a citation/figure pointer whose
+# rendered text is noise like "[12]", which `html_to_markdown` then strips.
+_UNWRAPPED_TAGS = ("xref", "styled-content", "named-content")
+_RENAMED_TAGS = {
+    "sec": "div",
+    "italic": "em",
+    "bold": "strong",
+    "underline": "u",
+    "monospace": "code",
+    "list-item": "li",
+    "table-wrap": "div",
+    "disp-quote": "blockquote",
+    "break": "br",
+    "label": "strong",
+}
+
+
+class PubMedFetchError(ScrapeError):
+    """Raised when a guideline cannot be sourced from PubMed or PMC."""
+
+
+@dataclass(frozen=True)
+class PubMedArticleRef:
+    """A PubMed guideline reference resolved from the search listing."""
+
+    pmid: str = ""
+    pmcid: str = ""
+    title: str = ""
+    journal: str = ""
+    pub_date: str = ""
+    doi: str = ""
+
+    @property
+    def page_url(self) -> str:
+        """Canonical PubMed record URL, falling back to the PMC article URL."""
+        return f"{BASE_URL}/{self.pmid}/" if self.pmid else self.pmc_url
+
+    @property
+    def pmc_url(self) -> str:
+        """PMC full-text article URL."""
+        return f"{PMC_ARTICLE_URL}/{self.pmcid}/"
+
+    @property
+    def slug(self) -> str:
+        """Stable identifier used for `external_id`."""
+        return self.pmid or self.pmcid
+
+
+@dataclass(frozen=True)
+class PubMedListingPage:
+    """One page of PubMed guideline search results."""
+
+    refs: list[PubMedArticleRef]
+    total: int | None
+
+
+def pubmed_ref_from_url(url: str) -> PubMedArticleRef:
+    """Parse a PubMed or PMC article URL into a guideline reference.
+
+    Only one of the two identifiers is known from a URL; the other is resolved
+    against E-utilities when the article is scraped.
+
+    Args:
+        url: PubMed or PMC article URL to parse.
+    """
+    parsed = urlparse(url.strip())
+    netloc = parsed.netloc.lower()
+    if parsed.scheme not in {"http", "https"}:
+        raise PubMedFetchError(f"Enter an http(s) PubMed or PMC URL; got {url!r}")
+
+    if netloc in {"pubmed.ncbi.nlm.nih.gov", "www.pubmed.ncbi.nlm.nih.gov"}:
+        match = _PUBMED_PATH_RE.match(parsed.path)
+        if match:
+            return PubMedArticleRef(pmid=match.group("pmid"))
+    elif netloc in {"www.ncbi.nlm.nih.gov", "ncbi.nlm.nih.gov", "pmc.ncbi.nlm.nih.gov"}:
+        match = _PMC_PATH_RE.match(parsed.path)
+        if match:
+            return PubMedArticleRef(pmcid=match.group("pmcid").upper())
+
+    raise PubMedFetchError(f"Enter a URL like {BASE_URL}/42476581/ or {PMC_ARTICLE_URL}/PMC13384732/; got {url!r}")
+
+
+def _policy_params() -> dict[str, str]:
+    """Identify the client per NCBI's E-utilities usage policy.
+
+    NCBI asks every request to carry a `tool` name and contact `email`, and
+    raises the rate limit from 3 to 10 requests/second when an `api_key` is
+    supplied. Both optional values come from the environment so that no personal
+    address is committed to the repository.
+    """
+    params = {"tool": NCBI_TOOL}
+    for name, variable in (("email", "NCBI_EMAIL"), ("api_key", "NCBI_API_KEY")):
+        value = os.environ.get(variable)
+        if value:
+            params[name] = value
+    return params
+
+
+def _eutils_get(client: httpx.Client, endpoint: str, params: dict[str, Any]) -> httpx.Response:
+    """Call one E-utilities endpoint, retrying when NCBI asks us to slow down.
+
+    `DOCUMENT_DELAY_SECONDS` paces one document against the next, but a single
+    document still makes up to two calls back to back, and the published 3/s
+    limit is per source address rather than per process. NCBI answers a burst
+    with 429. Without a retry that propagates out of `_scrape_or_skip`, which
+    only swallows `PubMedFetchError`, and kills a 3,000-document run partway
+    through.
+    """
+    url = f"{EUTILS_URL}/{endpoint}"
+    merged = {**params, **_policy_params()}
+    for attempt in range(_MAX_RETRIES):
+        response = client.get(url, params=merged)
+        if response.status_code in _RETRYABLE_STATUS and attempt < _MAX_RETRIES - 1:
+            delay = _RETRY_BACKOFF_SECONDS * 2**attempt
+            logger.warning("NCBI returned %s for %s; retrying in %.1fs", response.status_code, endpoint, delay)
+            time.sleep(delay)
+            continue
+        response.raise_for_status()
+        return response
+    raise PubMedFetchError(f"E-utilities {endpoint} did not succeed after {_MAX_RETRIES} attempts")
+
+
+def _summarize(client: httpx.Client, pmids: list[str]) -> list[PubMedArticleRef]:
+    """Resolve a batch of PMIDs to references carrying PMCIDs and citation data."""
+    payload = _eutils_get(
+        client,
+        "esummary.fcgi",
+        {"db": "pubmed", "id": ",".join(pmids), "retmode": "json"},
+    ).json()
+    result = payload.get("result", {})
+
+    refs: list[PubMedArticleRef] = []
+    for pmid in result.get("uids", []):
+        record = result.get(pmid, {})
+        article_ids = {entry.get("idtype"): entry.get("value") for entry in record.get("articleids", [])}
+        pmcid = article_ids.get("pmc", "")
+        if not pmcid:
+            # The open-access filter should guarantee a PMC copy, so a missing
+            # one means the record changed between search and summary.
+            logger.warning("Skipping PubMed record %s with no PMC identifier", pmid)
+            continue
+        refs.append(
+            PubMedArticleRef(
+                pmid=pmid,
+                pmcid=pmcid,
+                title=clean_text(record.get("title", ""), drop_numeric_citations=False),
+                journal=record.get("fulljournalname", ""),
+                pub_date=record.get("pubdate", ""),
+                doi=article_ids.get("doi", ""),
+            )
+        )
+    return refs
+
+
+def list_pubmed_guidelines(client: httpx.Client, page: int = 1) -> PubMedListingPage:
+    """List one page of open-access PubMed practice guidelines.
+
+    `esearch` paginates by numeric offset, so the page number maps directly onto
+    `retstart` and a page past the end returns an empty list rather than an
+    error. That is what terminates the scrape loop.
+
+    Args:
+        client: HTTP client used to call E-utilities.
+        page: 1-based listing page number (default: 1).
+    """
+    payload = _eutils_get(
+        client,
+        "esearch.fcgi",
+        {
+            "db": "pubmed",
+            "term": SEARCH_TERM,
+            "retstart": (page - 1) * LISTING_PAGE_SIZE,
+            "retmax": LISTING_PAGE_SIZE,
+            "retmode": "json",
+        },
+    ).json()
+    result = payload.get("esearchresult", {})
+    if "ERROR" in result:
+        raise PubMedFetchError(f"PubMed search error: {result['ERROR']}")
+
+    raw_total = str(result.get("count", ""))
+    total = int(raw_total) if raw_total.isdigit() else None
+    pmids = [str(pmid) for pmid in result.get("idlist", [])]
+    if not pmids:
+        return PubMedListingPage(refs=[], total=total)
+    return PubMedListingPage(refs=_summarize(client, pmids), total=total)
+
+
+def _fetch_pmc_article(client: httpx.Client, pmcid: str) -> etree._Element:
+    """Fetch one PMC record and return its `<article>` element."""
+    response = _eutils_get(
+        client,
+        "efetch.fcgi",
+        {"db": "pmc", "id": pmcid.upper().removeprefix("PMC"), "retmode": "xml"},
+    )
+    try:
+        root = etree.fromstring(response.content)
+    except etree.XMLSyntaxError as error:
+        raise PubMedFetchError(f"Malformed PMC XML for {pmcid}: {error}") from error
+
+    article = root.find(".//article")
+    if article is None:
+        raise PubMedFetchError(f"No PMC article returned for {pmcid}")
+    return article
+
+
+def _resolve_ref(client: httpx.Client, ref: PubMedArticleRef) -> PubMedArticleRef:
+    """Fill in a PMCID for a reference that only carries a PMID."""
+    if ref.pmcid or not ref.pmid:
+        return ref
+    resolved = _summarize(client, [ref.pmid])
+    if not resolved:
+        raise PubMedFetchError(f"No PMC full text for PubMed record {ref.pmid}")
+    return resolved[0]
+
+
+def _first_text(node: etree._Element, tag: str) -> str:
+    """Return the normalized text of the first matching descendant."""
+    element = node.find(f".//{tag}")
+    return clean_text("".join(element.itertext()), drop_numeric_citations=False) if element is not None else ""
+
+
+def _article_license(article: etree._Element) -> dict[str, str]:
+    """Extract licensing terms from the article's front matter.
+
+    The PMC Open Access Subset is not uniformly Creative Commons licensed. 88.3%
+    of the guideline slice carries a CC license, found in one of three shapes:
+    an `<ali:license_ref>` element, an `<ext-link>` pointing at
+    creativecommons.org, or a bare URL in the license free text. The name is
+    parsed from the URL path rather than from the `license-type` attribute,
+    which is unusable: the corpus spells it 18 different ways, including
+    `cc-by`, `creativeCommonsBy`, `CC BY-NC-ND`, `open-access` and `openaccess`.
+
+    The remaining 11.7% carry publisher terms that are not equivalent to each
+    other: most are Elsevier's COVID-19 resource centre grant, whose copyright
+    line still reads "All rights reserved"; some are the PMC Open Access
+    Subset's own "unrestricted re-use" statement; and 112 have no `<license>`
+    element at all, only a plain copyright line such as "(c) Springer-Verlag
+    Tokyo 2007".
+    Being in the subset is therefore not by itself a grant to redistribute, so
+    the raw terms are recorded rather than flattened to an empty license.
+    """
+    # The reservation of rights sits in `<copyright-statement>`, a sibling of
+    # `<license>` rather than a child, so reading only the license element loses
+    # the "All rights reserved" half of a COVID-era temporary grant.
+    copyright_statement = _first_text(article, "copyright-statement")
+
+    license_element = article.find(".//license")
+    if license_element is None:
+        return {
+            "license": "",
+            "license_url": "",
+            "license_type": "",
+            "license_statement": "",
+            "copyright_statement": copyright_statement,
+        }
+
+    url = ""
+    license_ref = license_element.find(f".//{_ALI_LICENSE_REF}")
+    if license_ref is not None and license_ref.text:
+        url = license_ref.text.strip()
+    if not url:
+        for element in license_element.iter():
+            href = element.get(_XLINK_HREF) or ""
+            if "creativecommons.org" in href:
+                url = href.strip()
+                break
+    if not url:
+        match = _CC_URL_RE.search("".join(license_element.itertext()))
+        url = match.group(0) if match else ""
+
+    name = ""
+    match = re.search(r"creativecommons\.org/(?:licenses|publicdomain)/([a-z0-9-]+)/", url)
+    if match:
+        token = match.group(1)
+        name = "CC0" if token == "zero" else f"CC {token.upper()}"
+
+    statement = clean_text("".join(license_element.itertext()), drop_numeric_citations=False)
+    return {
+        "license": name,
+        "license_url": url,
+        "license_type": license_element.get("license-type", ""),
+        "license_statement": statement[:_LICENSE_STATEMENT_CHARS],
+        "copyright_statement": copyright_statement,
+    }
+
+
+def _article_figures(article: etree._Element) -> list[dict[str, str]]:
+    """Record each figure's source filename, label and caption.
+
+    The image itself cannot be linked from here. JATS carries only a bare
+    filename (`keag320f1.jpg`), while the served URL inserts a CDN shard and a
+    content hash — `.../pmc/blobs/1ab4/13384732/bd9a2d61ca1a/keag320f1.jpg` —
+    that appear nowhere in the API response. Building a URL from the filename
+    alone yields a 404, which is worse than no link because nothing downstream
+    notices it is broken.
+
+    Other scrapers here keep images as absolute remote references (see the
+    `<img>` handling added in #9 and #10), which works because their sources
+    serve a real path. Recording the filename keeps that door open: a later
+    pass can resolve these against the rendered page or the OA package without
+    re-scraping the corpus.
+
+    Scans the whole article rather than just the body: a graphical abstract is
+    declared in `<front>`, so a body-only scan silently misses it.
+
+    Args:
+        article: The parsed `<article>` element, before tag rewriting.
+    """
+    figures: list[dict[str, str]] = []
+    for figure in article.iter("fig"):
+        graphic = figure.find(".//graphic")
+        href = graphic.get(_XLINK_HREF) if graphic is not None else None
+        if not href:
+            continue
+        figures.append(
+            {
+                "id": figure.get("id", ""),
+                "file": href,
+                "label": _first_text(figure, "label"),
+                "caption": _first_text(figure, "caption")[:_FIGURE_CAPTION_CHARS],
+            }
+        )
+    return figures
+
+
+def _article_supplements(article: etree._Element) -> list[dict[str, str]]:
+    """Record supplementary file names, labels and captions.
+
+    Same situation as `_article_figures`, and measured: across 40 sampled
+    guidelines every supplementary block was a pointer to an external file
+    rather than inline content, totalling 0.18% of body text. The evidence
+    tables a verifier would want live inside those `.docx` and `.tif` payloads,
+    which the API does not return, so the pointer is the only thing worth
+    keeping.
+
+    Args:
+        article: The parsed `<article>` element, before tag rewriting.
+    """
+    supplements: list[dict[str, str]] = []
+    for supplement in article.iter("supplementary-material"):
+        href = supplement.get(_XLINK_HREF)
+        if not href:
+            media = supplement.find(f".//*[@{_XLINK_HREF}]")
+            href = media.get(_XLINK_HREF) if media is not None else None
+        if not href:
+            continue
+        supplements.append(
+            {
+                "id": supplement.get("id", ""),
+                "file": href,
+                "label": _first_text(supplement, "label"),
+                "caption": _first_text(supplement, "caption")[:_FIGURE_CAPTION_CHARS],
+            }
+        )
+    return supplements
+
+
+def _heading_depth(section: etree._Element) -> int:
+    """Return how deeply a `<sec>` is nested inside the article body."""
+    depth = 1
+    parent = section.getparent()
+    while parent is not None:
+        if parent.tag == "sec":
+            depth += 1
+        parent = parent.getparent()
+    return depth
+
+
+def _jats_to_html(source: etree._Element) -> str:
+    """Rewrite a JATS subtree into HTML that `html_to_markdown` understands.
+
+    JATS is close enough to HTML that renaming tags is cheaper and less
+    error-prone than writing a second markdown serializer: `<table-wrap>`
+    already contains genuine XHTML tables, and inline markup maps one-to-one.
+    """
+    root = copy.deepcopy(source)
+    etree.strip_elements(root, *_DROPPED_TAGS, with_tail=False)
+    etree.strip_tags(root, *_UNWRAPPED_TAGS)
+
+    # An `<abstract>` labels itself "Abstract", which would duplicate the heading
+    # this module already writes above it.
+    if root.tag == "abstract":
+        title = root.find("title")
+        if title is not None:
+            root.remove(title)
+
+    # Headings depend on `<sec>` nesting, so resolve them before `sec` is renamed.
+    for section in root.iter("sec"):
+        title = section.find("title")
+        if title is not None:
+            title.tag = f"h{min(_heading_depth(section) + 1, 6)}"
+    for title in root.iter("title"):
+        title.tag = "strong"
+
+    for element in root.iter():
+        if not isinstance(element.tag, str):
+            continue
+        if element.tag == "list":
+            element.tag = "ol" if element.get("list-type") == "order" else "ul"
+        elif element.tag == "ext-link":
+            href = element.get(_XLINK_HREF)
+            element.tag = "a"
+            if href:
+                element.set("href", href)
+        else:
+            element.tag = _RENAMED_TAGS.get(element.tag, element.tag)
+        for name in list(element.attrib):
+            if name.startswith("{") or name in {"list-type", "content-type", "position"}:
+                del element.attrib[name]
+
+    return etree.tostring(root, encoding="unicode", method="html")
+
+
+def _jats_to_markdown(source: etree._Element, *, link_mode: LinkMode) -> str:
+    """Convert a JATS subtree to markdown and close up gaps left by dropped nodes.
+
+    The spacing pass has to run last: `html_to_markdown` is what removes the
+    "[12]" text of an unwrapped `xref`, so the orphaned space only appears once
+    the markdown exists.
+    """
+    markdown = html_to_markdown(_jats_to_html(source), link_mode=link_mode)
+    return _ORPHAN_SPACE_RE.sub(r"\1", markdown)
+
+
+def build_pubmed_article_text(
+    client: httpx.Client,
+    ref: PubMedArticleRef,
+    *,
+    link_mode: LinkMode = LinkMode.KEEP,
+) -> tuple[str, int, str, dict[str, Any]]:
+    """Scrape one guideline's full text into markdown, section count, title and metadata.
+
+    Args:
+        client: HTTP client used to call E-utilities.
+        ref: PubMed guideline reference to scrape.
+        link_mode: Whether links are kept as markdown links or stripped to their
+            visible text (default: LinkMode.KEEP).
+    """
+    ref = _resolve_ref(client, ref)
+    article = _fetch_pmc_article(client, ref.pmcid)
+
+    body = article.find(".//body")
+    if body is None:
+        # Roughly 2% of the subset is deposited as metadata only. That is a
+        # property of the record, not a fetch failure.
+        raise PubMedFetchError(f"No full text body in PMC record {ref.pmcid}")
+
+    sections: list[str] = []
+    abstract = article.find(".//abstract")
+    if abstract is not None:
+        abstract_markdown = _jats_to_markdown(abstract, link_mode=link_mode)
+        if abstract_markdown:
+            sections.append(f"## Abstract\n\n{abstract_markdown}")
+
+    body_markdown = _jats_to_markdown(body, link_mode=link_mode)
+    if body_markdown:
+        sections.append(body_markdown)
+
+    content = "\n\n".join(sections).strip()
+    if not content:
+        raise PubMedFetchError(f"No readable content in PMC record {ref.pmcid}")
+
+    title = ref.title or _first_text(article, "article-title") or ref.slug
+    section_count = max(len(body.findall("sec")), 1) + (1 if abstract is not None else 0)
+    metadata = {
+        "pmid": ref.pmid or _pmid_from_article(article),
+        "pmcid": ref.pmcid,
+        "doi": ref.doi or _article_id(article, "doi"),
+        "journal": ref.journal or _first_text(article, "journal-title"),
+        "pub_date": ref.pub_date,
+        "article_type": article.get("article-type", ""),
+        **_article_license(article),
+        "figures": _article_figures(article),
+        "supplements": _article_supplements(article),
+        "content_length_chars": len(content),
+    }
+    return content, section_count, title, metadata
+
+
+def _article_id(article: etree._Element, id_type: str) -> str:
+    """Return an `<article-id>` value of the requested type."""
+    for element in article.iter("article-id"):
+        if element.get("pub-id-type") == id_type:
+            return "".join(element.itertext()).strip()
+    return ""
+
+
+def _pmid_from_article(article: etree._Element) -> str:
+    return _article_id(article, "pmid")
+
+
+def scrape_pubmed_article(
+    client: httpx.Client,
+    ref: PubMedArticleRef,
+    *,
+    link_mode: LinkMode = LinkMode.KEEP,
+) -> ScrapedDocument:
+    """Scrape a PubMed guideline into a normalized document.
+
+    Args:
+        client: HTTP client used to call E-utilities.
+        ref: PubMed guideline reference to scrape.
+        link_mode: Whether links are kept as markdown links or stripped to their
+            visible text (default: LinkMode.KEEP).
+    """
+    content, section_count, title, metadata = build_pubmed_article_text(client, ref, link_mode=link_mode)
+    # Prefer the PMID from the record itself so one article gets one identifier
+    # whether it was reached from the listing or from a PMC URL, which carries
+    # no PMID of its own.
+    slug = metadata["pmid"] or ref.slug or metadata["pmcid"]
+    return ScrapedDocument(
+        source="pubmed",
+        external_id=f"pubmed-{slug}",
+        title=title,
+        url=ref.page_url,
+        content=content,
+        section_count=section_count,
+        metadata=metadata,
+    )
+
+
+def _scrape_or_skip(
+    client: httpx.Client,
+    ref: PubMedArticleRef,
+    *,
+    link_mode: LinkMode,
+) -> ScrapedDocument | None:
+    """Scrape one guideline, skipping records PMC holds without full text.
+
+    About 2% of the open-access subset is deposited as metadata only, so a run
+    over the whole corpus should not die when it reaches one.
+
+    Args:
+        client: HTTP client used to call E-utilities.
+        ref: PubMed guideline reference to scrape.
+        link_mode: Whether links are kept as markdown links or stripped to their
+            visible text.
+    """
+    try:
+        return scrape_pubmed_article(client, ref, link_mode=link_mode)
+    except PubMedFetchError:
+        logger.warning("Skipping PubMed guideline %r", ref.slug, exc_info=True)
+        return None
+
+
+def scrape_pubmed(
+    *,
+    documents: int | None,
+    link_mode: LinkMode = LinkMode.KEEP,
+    url: str | None = None,
+) -> ScrapeRun:
+    """Scrape PubMed guidelines from a URL or the open-access search listing.
+
+    Args:
+        documents: Number of documents to scrape. Ignored when `url` is set.
+            When unset, listing pages are fetched until a page returns no items
+            (default: None).
+        link_mode: Whether links are kept as markdown links or stripped to their
+            visible text (default: LinkMode.KEEP).
+        url: PubMed or PMC article URL to scrape as a single document
+            (default: None).
+    """
+    if url is not None:
+
+        def scrape_url() -> Iterable[ScrapedDocument]:
+            with default_client() as client:
+                yield scrape_pubmed_article(client, pubmed_ref_from_url(url), link_mode=link_mode)
+
+        return ScrapeRun(documents=scrape_url(), total=1)
+
+    with default_client() as client:
+        first_page = list_pubmed_guidelines(client, page=1)
+    total = first_page.total if documents is None or first_page.total is None else min(documents, first_page.total)
+    return ScrapeRun(
+        total=total,
+        documents=scrape_listing_documents(
+            documents=documents,
+            client_factory=default_client,
+            first_page_items=first_page.refs,
+            list_page=lambda client, page: list_pubmed_guidelines(client, page).refs,
+            scrape_item=lambda client, ref: _scrape_or_skip(client, ref, link_mode=link_mode),
+            document_delay_seconds=DOCUMENT_DELAY_SECONDS,
+        ),
+    )
+
+
+__all__ = [
+    "BASE_URL",
+    "DOCUMENT_DELAY_SECONDS",
+    "EUTILS_URL",
+    "PMC_ARTICLE_URL",
+    "PUBMED_DATASET_DISPLAY_NAME",
+    "PUBMED_DATASET_NAME",
+    "SEARCH_TERM",
+    "PubMedArticleRef",
+    "PubMedFetchError",
+    "PubMedListingPage",
+    "build_pubmed_article_text",
+    "list_pubmed_guidelines",
+    "pubmed_ref_from_url",
+    "scrape_pubmed",
+    "scrape_pubmed_article",
+]
diff --git a/datasets/test/test_scraping_base.py b/datasets/test/test_scraping_base.py
index eed3c83..2201e4d 100644
--- a/datasets/test/test_scraping_base.py
+++ b/datasets/test/test_scraping_base.py
@@ -149,3 +149,43 @@ def scrape_item(client: httpx.Client, item: str) -> ScrapedDocument:
 
     assert [document.external_id for document in documents] == ["item-1", "item-2", "item-3"]
     assert delays == [5.0, 5.0]
+
+
+def test_scrape_listing_documents_skips_non_documents_without_consuming_limit(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Skipped listing entries are delayed but do not count as returned documents."""
+    delays: list[float] = []
+
+    class _FakeClient:
+        def __enter__(self) -> "_FakeClient":
+            return self
+
+        def __exit__(self, *args: object) -> None:
+            return None
+
+    def client_factory():
+        return _FakeClient()
+
+    def list_page(client: httpx.Client, page: int) -> list[str]:
+        return ["skip", "item-1", "item-2"] if page == 1 else []
+
+    def scrape_item(client: httpx.Client, item: str) -> ScrapedDocument | None:
+        if item == "skip":
+            return None
+        return ScrapedDocument("test", item, item, f"https://example.org/{item}", "content")
+
+    monkeypatch.setattr(base.time, "sleep", delays.append)
+
+    documents = list(
+        scrape_listing_documents(
+            documents=2,
+            client_factory=client_factory,
+            list_page=list_page,
+            scrape_item=scrape_item,
+            document_delay_seconds=5.0,
+        )
+    )
+
+    assert [document.external_id for document in documents] == ["item-1", "item-2"]
+    assert delays == [5.0, 5.0]
diff --git a/datasets/test/test_scraping_pubmed.py b/datasets/test/test_scraping_pubmed.py
new file mode 100644
index 0000000..16deaab
--- /dev/null
+++ b/datasets/test/test_scraping_pubmed.py
@@ -0,0 +1,478 @@
+"""Tests for PubMed scraping helpers."""
+
+import json
+
+import httpx
+import pytest
+
+from amfv_datasets.scraping import base
+from amfv_datasets.scraping.html import LinkMode
+from amfv_datasets.scraping.pubmed import (
+    LISTING_PAGE_SIZE,
+    PubMedArticleRef,
+    PubMedFetchError,
+    build_pubmed_article_text,
+    list_pubmed_guidelines,
+    pubmed_ref_from_url,
+    scrape_pubmed,
+    scrape_pubmed_article,
+)
+
+_BODY = """
+<body>
+  <sec><title>Scope and purpose</title>
+    <p>This guideline covers <italic>adult</italic> hypertension.</p>
+    <sec><title>Guideline objectives</title><p>Reduce cardiovascular risk.</p></sec>
+  </sec>
+  <sec><title>Recommendations</title>
+    <p>Treat to target <xref ref-type="bibr" rid="r1">[1]</xref> .</p>
+    <table-wrap><label>Table 1</label>
+      <caption><title>Thresholds</title></caption>
+      <table>
+        <thead><tr><th>Stage</th><th>Threshold</th></tr></thead>
+        <tbody><tr><td>Stage 2</td><td>140/90 mmHg</td></tr></tbody>
+      </table>
+    </table-wrap>
+    <list list-type="order"><list-item><p>Measure blood pressure.</p></list-item></list>
+  </sec>
+  <sec><title>Treatment algorithm</title>
+    <fig id="g1-F1"><label>Figure 1</label>
+      <caption><p>Stepped care algorithm for resistant hypertension.</p></caption>
+      <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="g1f1.jpg"/>
+    </fig>
+  </sec>
+  <supplementary-material content-type="local-data" id="MOESM1">
+    <media xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="12345_MOESM1_ESM.docx"/>
+    <caption><p>Additional file 1: Table S1. Evidence profile for each recommendation.</p></caption>
+  </supplementary-material>
+  <ref-list><ref id="r1"><mixed-citation>Smith J. Irrelevant citation.</mixed-citation></ref></ref-list>
+</body>
+"""
+
+_LICENSE_ALI = (
+    "<license><ali:license_ref>https://creativecommons.org/licenses/by/4.0/</ali:license_ref>"
+    "<license-p>Open access.</license-p></license>"
+)
+_LICENSE_EXT_LINK = (
+    "<license><license-p>Distributed under the "
+    '<ext-link ext-link-type="uri" xlink:href="https://creativecommons.org/licenses/by-nc/4.0/">'
+    "CC BY-NC</ext-link> license.</license-p></license>"
+)
+_LICENSE_TEXT_ONLY = (
+    "<license><license-p>Distributed under "
+    "https://creativecommons.org/licenses/by-nc-nd/4.0/ terms.</license-p></license>"
+)
+# 11.7% of the open-access subset carries publisher terms instead of a CC
+# license, and they are not equivalent to each other.
+_LICENSE_NON_CC_PERMISSIVE = (
+    '<license license-type="open-access"><license-p>This article is made available via the '
+    "PMC Open Access Subset for unrestricted re-use and analyses in any form or by any means "
+    "with acknowledgement of the original source.</license-p></license>"
+)
+_LICENSE_NON_CC_RESERVED = (
+    "<copyright-statement>© 2020 Elsevier Masson SAS. All rights reserved.</copyright-statement>"
+    "<license><license-p>Since January 2020 Elsevier has created a COVID-19 resource centre "
+    "with free information.</license-p></license>"
+)
+
+
+def _jats(*, body: str = _BODY, license_block: str = _LICENSE_ALI, abstract: str = "") -> str:
+    """Build a minimal but structurally faithful PMC JATS response."""
+    return (
+        '<?xml version="1.0"?>'
+        '<pmc-articleset><article article-type="review-article"'
+        ' xmlns:xlink="http://www.w3.org/1999/xlink"'
+        ' xmlns:ali="http://www.niso.org/schemas/ali/1.0/">'
+        "<front>"
+        "<journal-meta><journal-title>Journal of Guidelines</journal-title></journal-meta>"
+        "<article-meta>"
+        '<article-id pub-id-type="pmid">42476581</article-id>'
+        '<article-id pub-id-type="pmcid">PMC13384732</article-id>'
+        '<article-id pub-id-type="doi">10.1093/example.1</article-id>'
+        "<title-group><article-title>Hypertension guideline</article-title></title-group>"
+        f"<permissions>{license_block}</permissions>"
+        f"{abstract}"
+        "</article-meta></front>"
+        f"{body}"
+        "</article></pmc-articleset>"
+    )
+
+
+def _article_client(xml: str) -> httpx.Client:
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.url.path.endswith("efetch.fcgi")
+        assert request.url.params["db"] == "pmc"
+        # NCBI's usage policy asks every request to name the calling tool.
+        assert request.url.params["tool"] == "amfv"
+        return httpx.Response(200, content=xml.encode())
+
+    return httpx.Client(transport=httpx.MockTransport(handler))
+
+
+def _listing_handler(
+    pages: dict[int, list[str]],
+    *,
+    total: int,
+    summaries: dict[str, dict] | None = None,
+    seen_offsets: list[int] | None = None,
+):
+    """Serve esearch/esummary/efetch for a fake corpus keyed by PMID."""
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        path = request.url.path
+        params = request.url.params
+        if path.endswith("esearch.fcgi"):
+            offset = int(params["retstart"])
+            if seen_offsets is not None:
+                seen_offsets.append(offset)
+            page = offset // LISTING_PAGE_SIZE + 1
+            return httpx.Response(
+                200,
+                text=json.dumps({"esearchresult": {"count": str(total), "idlist": pages.get(page, [])}}),
+            )
+        if path.endswith("esummary.fcgi"):
+            uids = params["id"].split(",")
+            result = {"uids": uids}
+            for uid in uids:
+                result[uid] = (summaries or {}).get(
+                    uid,
+                    {
+                        "title": f"Guideline {uid}",
+                        "fulljournalname": "Journal of Guidelines",
+                        "pubdate": "2026 Jan 1",
+                        "articleids": [
+                            {"idtype": "pubmed", "value": uid},
+                            {"idtype": "doi", "value": f"10.1000/{uid}"},
+                            {"idtype": "pmc", "value": f"PMC{uid}"},
+                        ],
+                    },
+                )
+            return httpx.Response(200, text=json.dumps({"result": result}))
+        pmcid = params["id"]
+        if pmcid == "999":
+            # PMC holds the record but no full text was deposited.
+            return httpx.Response(200, content=_jats(body="").encode())
+        return httpx.Response(200, content=_jats().encode())
+
+    return handler
+
+
+def test_list_pubmed_guidelines_resolves_pmids_to_refs_with_pmcids() -> None:
+    """One esearch plus one esummary yields refs carrying full citation metadata."""
+    client = httpx.Client(transport=httpx.MockTransport(_listing_handler({1: ["111", "222"]}, total=2)))
+
+    listing = list_pubmed_guidelines(client)
+
+    assert listing.total == 2
+    assert [ref.pmid for ref in listing.refs] == ["111", "222"]
+    assert listing.refs[0].pmcid == "PMC111"
+    assert listing.refs[0].title == "Guideline 111"
+    assert listing.refs[0].doi == "10.1000/111"
+    assert listing.refs[0].page_url == "https://pubmed.ncbi.nlm.nih.gov/111/"
+
+
+def test_list_pubmed_guidelines_pages_by_numeric_offset() -> None:
+    """Page number maps onto `retstart`, which is what makes paging work at all."""
+    seen: list[int] = []
+    client = httpx.Client(transport=httpx.MockTransport(_listing_handler({3: ["333"]}, total=900, seen_offsets=seen)))
+
+    listing = list_pubmed_guidelines(client, page=3)
+
+    assert seen == [2 * LISTING_PAGE_SIZE]
+    assert [ref.pmid for ref in listing.refs] == ["333"]
+
+
+def test_list_pubmed_guidelines_returns_no_refs_past_the_end_of_the_listing() -> None:
+    """An empty page terminates the scrape loop rather than raising."""
+    client = httpx.Client(transport=httpx.MockTransport(_listing_handler({}, total=2)))
+
+    listing = list_pubmed_guidelines(client, page=99)
+
+    assert listing.refs == []
+    assert listing.total == 2
+
+
+def test_list_pubmed_guidelines_skips_records_with_no_pmc_copy() -> None:
+    """The open-access filter should guarantee a PMC id; a record without one is dropped."""
+    summaries = {
+        "111": {"title": "No full text", "articleids": [{"idtype": "pubmed", "value": "111"}]},
+    }
+    client = httpx.Client(
+        transport=httpx.MockTransport(_listing_handler({1: ["111", "222"]}, total=2, summaries=summaries))
+    )
+
+    listing = list_pubmed_guidelines(client)
+
+    assert [ref.pmid for ref in listing.refs] == ["222"]
+
+
+def test_build_pubmed_article_text_maps_jats_sections_to_nested_headings() -> None:
+    """`<sec>` nesting depth becomes markdown heading depth."""
+    content, section_count, title, metadata = build_pubmed_article_text(
+        _article_client(_jats()),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+        link_mode=LinkMode.STRIP,
+    )
+
+    assert "## Scope and purpose" in content
+    assert "### Guideline objectives" in content
+    assert "## Recommendations" in content
+    assert title == "Hypertension guideline"
+    assert section_count == 3
+    assert metadata["journal"] == "Journal of Guidelines"
+    assert metadata["article_type"] == "review-article"
+    assert metadata["content_length_chars"] == len(content)
+
+
+def test_build_pubmed_article_text_keeps_clinical_tables_and_drops_citation_pointers() -> None:
+    """Recommendation thresholds must survive; `xref` markers and reference lists must not."""
+    content, _, _, _ = build_pubmed_article_text(
+        _article_client(_jats()),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert "140/90 mmHg" in content
+    assert "Measure blood pressure" in content
+    # The `[1]` pointer and the reference list it points at are citation
+    # apparatus, not clinical content.
+    assert "[1]" not in content
+    assert "Irrelevant citation" not in content
+    # Unwrapping the pointer must not leave " ." behind.
+    assert "Treat to target ." not in content
+    assert "Treat to target." in content
+
+
+def test_build_pubmed_article_text_records_figures_it_cannot_link() -> None:
+    """The image URL is not derivable from the API, so keep the filename for a later pass."""
+    content, _, _, metadata = build_pubmed_article_text(
+        _article_client(_jats()),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert metadata["figures"] == [
+        {
+            "id": "g1-F1",
+            "file": "g1f1.jpg",
+            "label": "Figure 1",
+            "caption": "Stepped care algorithm for resistant hypertension.",
+        }
+    ]
+    # The caption stays readable in the text; only the unlinkable image goes.
+    assert "Stepped care algorithm" in content
+    assert "g1f1.jpg" not in content
+
+
+def test_build_pubmed_article_text_records_supplementary_files() -> None:
+    """Evidence tables live in supplementary .docx payloads the API does not return."""
+    content, _, _, metadata = build_pubmed_article_text(
+        _article_client(_jats()),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert metadata["supplements"] == [
+        {
+            "id": "MOESM1",
+            "file": "12345_MOESM1_ESM.docx",
+            "label": "",
+            "caption": "Additional file 1: Table S1. Evidence profile for each recommendation.",
+        }
+    ]
+    assert "12345_MOESM1_ESM.docx" not in content
+
+
+def test_build_pubmed_article_text_does_not_repeat_the_abstract_heading() -> None:
+    """JATS labels the abstract itself, which would duplicate the heading we add."""
+    content, section_count, _, _ = build_pubmed_article_text(
+        _article_client(_jats(abstract="<abstract><title>Abstract</title><p>Summary text.</p></abstract>")),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert content.startswith("## Abstract")
+    assert "**Abstract**" not in content
+    assert "Summary text." in content
+    # Three body sections plus the abstract.
+    assert section_count == 4
+
+
+@pytest.mark.parametrize(
+    ("license_block", "expected_name", "expected_url"),
+    [
+        (_LICENSE_ALI, "CC BY", "https://creativecommons.org/licenses/by/4.0/"),
+        (_LICENSE_EXT_LINK, "CC BY-NC", "https://creativecommons.org/licenses/by-nc/4.0/"),
+        (_LICENSE_TEXT_ONLY, "CC BY-NC-ND", "https://creativecommons.org/licenses/by-nc-nd/4.0/"),
+    ],
+)
+def test_build_pubmed_article_text_reads_every_license_shape(
+    license_block: str, expected_name: str, expected_url: str
+) -> None:
+    """All three shapes occur in the open-access subset, and ND changes what we may redistribute."""
+    _, _, _, metadata = build_pubmed_article_text(
+        _article_client(_jats(license_block=license_block)),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert metadata["license"] == expected_name
+    assert metadata["license_url"] == expected_url
+
+
+def test_build_pubmed_article_text_records_permissive_publisher_terms() -> None:
+    """A publisher license is not a missing license, so the terms are kept verbatim."""
+    _, _, _, metadata = build_pubmed_article_text(
+        _article_client(_jats(license_block=_LICENSE_NON_CC_PERMISSIVE)),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert metadata["license"] == ""
+    assert metadata["license_url"] == ""
+    assert metadata["license_type"] == "open-access"
+    assert "unrestricted re-use" in metadata["license_statement"]
+
+
+def test_build_pubmed_article_text_records_a_reserved_copyright_statement() -> None:
+    """COVID-era free access still reserves all rights, and that text is not inside `<license>`."""
+    _, _, _, metadata = build_pubmed_article_text(
+        _article_client(_jats(license_block=_LICENSE_NON_CC_RESERVED)),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert metadata["license"] == ""
+    # Reading only `<license>` would report free access and lose the reservation.
+    assert "free information" in metadata["license_statement"]
+    assert "All rights reserved" in metadata["copyright_statement"]
+
+
+def test_build_pubmed_article_text_rejects_a_metadata_only_record() -> None:
+    """About 2% of the subset has no deposited full text."""
+    with pytest.raises(PubMedFetchError):
+        build_pubmed_article_text(
+            _article_client(_jats(body="")),
+            PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+        )
+
+
+def test_scrape_pubmed_article_normalizes_into_a_scraped_document() -> None:
+    """Scraped guidelines use the shared source/external_id conventions."""
+    document = scrape_pubmed_article(
+        _article_client(_jats()),
+        PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"),
+    )
+
+    assert document.source == "pubmed"
+    assert document.external_id == "pubmed-42476581"
+    assert document.url == "https://pubmed.ncbi.nlm.nih.gov/42476581/"
+    assert document.metadata["pmcid"] == "PMC13384732"
+    assert "Scope and purpose" in document.content
+
+
+def test_scrape_pubmed_pages_through_the_listing_and_terminates(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Paging advances by offset, crosses a page boundary, and stops on the empty page."""
+    seen: list[int] = []
+    handler = _listing_handler({1: ["111"], 2: ["222"]}, total=2, seen_offsets=seen)
+    monkeypatch.setattr(
+        "amfv_datasets.scraping.pubmed.default_client",
+        lambda: httpx.Client(transport=httpx.MockTransport(handler)),
+    )
+    monkeypatch.setattr(base.time, "sleep", lambda _seconds: None)
+
+    run = scrape_pubmed(documents=None)
+    documents = list(run.documents)
+
+    assert run.total == 2
+    assert [document.external_id for document in documents] == ["pubmed-111", "pubmed-222"]
+    # Page 1 is fetched once for the total and reused via `first_page_items`,
+    # so the listing is not re-requested at offset 0 during the run.
+    assert seen == [0, LISTING_PAGE_SIZE, 2 * LISTING_PAGE_SIZE]
+
+
+def test_scrape_pubmed_skips_records_pmc_holds_without_full_text(monkeypatch: pytest.MonkeyPatch) -> None:
+    """One metadata-only record does not abort a run over the rest of the listing."""
+    handler = _listing_handler({1: ["999", "222"]}, total=2)
+    monkeypatch.setattr(
+        "amfv_datasets.scraping.pubmed.default_client",
+        lambda: httpx.Client(transport=httpx.MockTransport(handler)),
+    )
+    monkeypatch.setattr(base.time, "sleep", lambda _seconds: None)
+
+    documents = list(scrape_pubmed(documents=None).documents)
+
+    assert [document.external_id for document in documents] == ["pubmed-222"]
+
+
+def test_eutils_retries_when_ncbi_rate_limits(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A 429 mid-run must not kill the scrape; NCBI returns them on bursts."""
+    monkeypatch.setattr("amfv_datasets.scraping.pubmed.time.sleep", lambda _seconds: None)
+    attempts = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        attempts.append(request.url.path)
+        if len(attempts) < 3:
+            return httpx.Response(429, text="Too Many Requests")
+        return httpx.Response(200, content=_jats().encode())
+
+    client = httpx.Client(transport=httpx.MockTransport(handler))
+    document = scrape_pubmed_article(client, PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"))
+
+    assert len(attempts) == 3
+    assert document.external_id == "pubmed-42476581"
+
+
+def test_eutils_gives_up_after_repeated_rate_limits(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Persistent 429s are a real stop signal, not something to retry forever."""
+    monkeypatch.setattr("amfv_datasets.scraping.pubmed.time.sleep", lambda _seconds: None)
+    attempts = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        attempts.append(request.url.path)
+        return httpx.Response(429, text="Too Many Requests")
+
+    client = httpx.Client(transport=httpx.MockTransport(handler))
+    with pytest.raises(httpx.HTTPStatusError):
+        scrape_pubmed_article(client, PubMedArticleRef(pmid="42476581", pmcid="PMC13384732"))
+
+    assert len(attempts) == 4
+
+
+def test_pubmed_ref_from_url_accepts_both_pubmed_and_pmc_urls() -> None:
+    """Only one identifier is knowable from a URL; the other is resolved when scraping."""
+    pubmed_ref = pubmed_ref_from_url("https://pubmed.ncbi.nlm.nih.gov/42476581/")
+    pmc_ref = pubmed_ref_from_url("https://www.ncbi.nlm.nih.gov/pmc/articles/PMC13384732/")
+
+    assert pubmed_ref == PubMedArticleRef(pmid="42476581")
+    assert pmc_ref == PubMedArticleRef(pmcid="PMC13384732")
+    assert pmc_ref.page_url == "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC13384732/"
+
+
+def test_scrape_pubmed_article_uses_the_same_id_from_either_entry_point() -> None:
+    """A PMC URL carries no PMID, but the record does, so both routes agree."""
+    from_listing = scrape_pubmed_article(
+        _article_client(_jats()), PubMedArticleRef(pmid="42476581", pmcid="PMC13384732")
+    )
+    from_pmc_url = scrape_pubmed_article(_article_client(_jats()), PubMedArticleRef(pmcid="PMC13384732"))
+
+    assert from_listing.external_id == from_pmc_url.external_id == "pubmed-42476581"
+
+
+def test_pubmed_ref_from_url_resolves_a_pmid_to_full_text(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A PubMed URL carries no PMCID, so efetch needs one looked up first."""
+    handler = _listing_handler({1: ["111"]}, total=1)
+    client = httpx.Client(transport=httpx.MockTransport(handler))
+
+    document = scrape_pubmed_article(client, pubmed_ref_from_url("https://pubmed.ncbi.nlm.nih.gov/111/"))
+
+    assert document.external_id == "pubmed-111"
+    assert document.metadata["pmcid"] == "PMC111"
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "https://example.org/42476581/",
+        "https://pubmed.ncbi.nlm.nih.gov/not-a-pmid/",
+        "https://www.ncbi.nlm.nih.gov/pmc/articles/13384732/",
+        "ftp://pubmed.ncbi.nlm.nih.gov/42476581/",
+    ],
+)
+def test_pubmed_ref_from_url_rejects_non_article_urls(url: str) -> None:
+    """Anything that is not a PubMed or PMC article URL is an error, not a guess."""
+    with pytest.raises(PubMedFetchError):
+        pubmed_ref_from_url(url)