# Enforcing NIH 12-page limit rules programmatically

The National Institutes of Health (NIH) enforces a hard 12-page ceiling on the Research Strategy of a standard R01 application, and an over-length submission is not scored, edited, or returned for correction — the eRA Commons validation layer rejects it outright before peer review ever begins. That single failure mode wastes an entire funding cycle for a principal investigator, so page-limit checking cannot be a manual eyeball pass the night before a Grants.gov deadline. This page shows how to build a deterministic, coordinate-aware validator for that exact rule as one detector inside the broader page-limit and font enforcement toolkit. Reliable enforcement means moving past naive sheet counting and parsing the document at the content-stream and glyph level, because the 12-page limit interacts with font-size floors, margin minimums, and section-scoping rules that a page tally alone can never see.

# Phase 1 — Isolate the Research Strategy before counting anything

The NIH page limit applies only to the Research Strategy. It explicitly excludes the Specific Aims page, the bibliography, biosketches, the budget and its justification, and the resource-sharing and data-management plans. Counting raw PDF pages therefore over-counts every application and produces a validator that cries wolf. The first phase decomposes the assembled PDF and clips the validation scope to the target section, mirroring the section-scoping logic used by the required-section mapping engine.

Implementation steps:

1. Parse the PDF object model. Read the document outline tree (/Outlines, or /Names/Dests when bookmarks are flattened) to map logical section names to physical page ranges. NIH assembly through eRA Commons injects bookmarks for each component, so this is the fast path.
2. Cross-reference structural headers. Using coordinate-aware extraction with pdfplumber, locate canonical headers — Significance, Innovation, Approach — that anchor the Research Strategy, and the Specific Aims and bibliography headers that bound it.
3. Compute content boundaries. Map the first and last page of the Research Strategy and strip every preceding and succeeding page from scope, so references and biosketches can never inflate the count.
4. Fallback heuristic. When the bookmark tree is malformed or missing, scan the top 12 % of each page for a header matching NIH nomenclature and treat that band as the section marker. Never silently default the whole document into scope — a missing anchor is a routed review case, not a pass.

Pin the environment so a validation run reproduces exactly when the same PDF is re-checked after an amendment:

python -m venv .venv
source .venv/bin/activate
pip install "pdfplumber==0.11.4" "pydantic>=2.6"

# Phase 2 — Count content-stream pages and validate typography

Physical sheet counts are unreliable because embedded media, floating figures, and variable leading distort where NIH considers a “page” to begin and end. Enforcement reconstructs logical page flow from the isolated content streams, then validates typography at the character level in the same pass — NIH mandates an 11-point minimum font size, a 0.5-inch (36-point) minimum margin on every edge, and an approved typeface set (Arial, Helvetica, Palatino Linotype, or Georgia). Both checks read the same page.chars records, so they run together.

Core transformation steps:

1. Segment the isolated pages. Keep only the page objects inside the Research Strategy range from Phase 1.
2. Aggregate text and vector objects. A page counts toward the limit when its content stream carries measurable text or graphical objects; ignore whitespace-only trailing pages.
3. Verify font size. Assert char["size"] >= 11.0 after a small rendering tolerance so hinted subsets do not throw false positives.
4. Enforce margin zones. Flag any glyph bounding box whose x0 < 36, x1 > page.width - 36, top < 36, or bottom > page.height - 36 — text that has crept into the reserved margin to buy space.
5. Normalize super/subscripts. Baseline-shifted footnote and citation markers can read as compressed line spacing; correct for the offset before flagging.

Codify the rule thresholds in a typed model rather than scattering magic numbers, using Pydantic v2 field_validator syntax so an out-of-policy configuration fails loudly at construction. This is the same Pydantic validation layer pattern the ingestion pipeline uses to harden parsed data.

from pydantic import BaseModel, field_validator

class NIHPageRule(BaseModel):
    """Versioned NIH formatting policy for a single activity code."""
    activity_code: str
    max_pages: int
    min_font_pt: float = 11.0
    min_margin_pt: float = 36.0  # 0.5 in x 72 pt/in
    approved_fonts: tuple[str, ...] = ("Arial", "Helvetica", "Palatino", "Georgia")

    @field_validator("max_pages")
    @classmethod
    def _positive_limit(cls, v: int) -> int:
        if v < 1:
            raise ValueError("max_pages must be a positive page ceiling")
        return v

    @field_validator("min_margin_pt")
    @classmethod
    def _sane_margin(cls, v: float) -> float:
        if not 0 < v <= 72:
            raise ValueError("min_margin_pt must fall within (0, 72] points")
        return v

The transformation itself walks the isolated pages, counts the ones bearing content, and records every glyph-level violation with its coordinates so a downstream annotator can circle the offending character for the grant writer:

import pdfplumber
from dataclasses import dataclass, field

@dataclass(slots=True)
class Violation:
    page: int
    kind: str          # "font" | "margin"
    x0: float
    top: float
    detail: str

@dataclass(slots=True)
class ComplianceResult:
    activity_code: str
    page_count: int
    violations: list[Violation] = field(default_factory=list)

    @property
    def is_compliant(self) -> bool:
        return not self.violations

def validate_research_strategy(
    strategy_pages: list["pdfplumber.page.Page"],
    rule: NIHPageRule,
) -> ComplianceResult:
    """Count content pages and flag font/margin violations against one rule.

    `strategy_pages` is the Phase-1 output: ONLY the Research Strategy pages.
    Coordinates are in points; page.chars carries per-glyph 'size'/'fontname'.
    """
    result = ComplianceResult(rule.activity_code, page_count=0)
    for n, page in enumerate(strategy_pages, start=1):
        chars = page.chars
        if not chars:
            continue  # blank trailing page: not counted
        result.page_count += 1
        right, bottom = page.width - rule.min_margin_pt, page.height - rule.min_margin_pt
        for ch in chars:
            if ch.get("size", 0) and ch["size"] < rule.min_font_pt:
                result.violations.append(
                    Violation(n, "font", ch["x0"], ch["top"],
                              f'{ch["size"]:.1f}pt < {rule.min_font_pt}pt'))
            if ch["x0"] < rule.min_margin_pt or ch["x1"] > right \
                    or ch["top"] < rule.min_margin_pt or ch["bottom"] > bottom:
                result.violations.append(
                    Violation(n, "margin", ch["x0"], ch["top"], "glyph in reserved margin"))
    if result.page_count > rule.max_pages:
        result.violations.append(
            Violation(result.page_count, "font",
                      0.0, 0.0, f"{result.page_count} pages > {rule.max_pages}"))
    return result

Two traps are worth calling out. Use page.chars, not extract_words() — the word grouper drops the size key you need for the font floor. And for PyMuPDF-based pipelines the equivalent metadata lives in page.get_text("dict")["blocks"][…]["lines"][…]["spans"], each span carrying its own "size".

The pipeline below shows how a submitted PDF moves from section isolation through page counting and typography checks to a final auditable compliance result.

# Phase 3 — Edge cases and agency-specific overrides

Two classes of problem break a validator that only counts and measures: rendering artifacts inside the PDF, and the fact that “12 pages” is not a universal constant.

Rendering and compression artifacts. PDF optimization workflows routinely introduce compliance-breaking noise:

• Flattened annotations and form fields. Strip /Annots, /AcroForm, and hidden Optional Content Groups (/OCGs) before measuring, without touching visible content, so a stray annotation box does not read as a margin intrusion.
• Hidden OCR layers. A scanned page re-run through optical character recognition carries a transparent zero-width text layer; detect glyphs with degenerate bounding boxes and exclude them from both page and font math.
• Rasterized text. When a page holds only image streams and no text operators, no font size exists to check — flag it for manual review rather than silently passing an image of over-size text.

Agency and activity-code overrides. The 12-page figure is specific to the R01 and similarly sized mechanisms. NIH itself varies the ceiling by activity code, and the limit is authoritative only for the version of the Funding Opportunity Announcement (FOA) in force — always read the page limit from the notice, not from a hard-coded constant, cross-checking against the NIH FOA schema mapping record for that opportunity. Sibling agencies scope the rule differently again: the NSF page-limit rules count a 15-page Project Description, and a Department of Defense (DoD) Broad Agency Announcement sets its own volume limits. Keep the ceiling data-driven, and let the compliance threshold tuning layer own the per-mechanism numbers.

# Phase 4 — Validation, verification, and an audit-safe record

Grant offices need immutable, reproducible compliance records, not a transient pass/fail. Before the result is trusted downstream — by the automated checklist generator or a pre-submission dashboard — bind it to the exact bytes that were checked and emit structured, versioned output.

import hashlib, json
from datetime import datetime, timezone

def audit_record(pdf_path: str, result: ComplianceResult, rule: NIHPageRule) -> str:
    """Serialize a reproducible, coordinate-anchored compliance record as JSON."""
    with open(pdf_path, "rb") as fh:
        digest = hashlib.sha256(fh.read()).hexdigest()
    return json.dumps({
        "pdf_sha256": digest,
        "checked_at": datetime.now(timezone.utc).isoformat(),
        "rule_version": f"nih_{rule.activity_code.lower()}_v1",
        "activity_code": rule.activity_code,
        "page_count": result.page_count,
        "max_pages": rule.max_pages,
        "is_compliant": result.is_compliant,
        "violations": [v.__dict__ for v in result.violations],
    }, indent=2, sort_keys=True)

Confirm correct behavior against committed fixtures rather than live agency PDFs, which change without notice:

def test_over_length_r01_is_flagged() -> None:
    rule = NIHPageRule(activity_code="R01", max_pages=12)
    pages = load_fixture_pages("tests/fixtures/r01_13_pages.pdf")  # Research Strategy only
    result = validate_research_strategy(pages, rule)
    assert not result.is_compliant
    assert any(v.detail.endswith("> 12") for v in result.violations)

def test_ten_point_font_violation_records_coordinates() -> None:
    rule = NIHPageRule(activity_code="R01", max_pages=12)
    pages = load_fixture_pages("tests/fixtures/r01_small_font.pdf")
    result = validate_research_strategy(pages, rule)
    font_flags = [v for v in result.violations if v.kind == "font"]
    assert font_flags and all(f.top > 0 for f in font_flags)

A manual acceptance checklist catches what fixtures miss: confirm references and biosketches were excluded from the count, that every violation carries a page and coordinate, that the ceiling was read from the FOA and not hard-coded, and that a corrupt file routes to review instead of crashing the batch. Only then release the JSON record to the audit log with the submitting user ID and timestamp, satisfying institutional record-retention policy.

# Frequently asked questions

# Related

• Page-limit & font enforcement — the parent toolkit these NIH checks plug into.
• Compliance threshold tuning — where per-mechanism page ceilings and font floors are owned.
• Required-section mapping — isolating and validating the sections a submission must contain.
• PDF text extraction with pdfplumber — the coordinate-aware extraction this validator reads from.
• NIH FOA schema mapping — the source of record for an opportunity’s authoritative page limit.

Up one level: Page-limit & font enforcement