Skip to content
cccskills
FreePublished on GitHub

pdf-verification-cli

Check PDF page counts, document details, and required text using command-line tools. This skill provides a verification workflow for environments without Python PDF libraries, including text extraction from selected pages and searches for expected sections.

OriginalShow the original description

Verify PDF page count and content using command-line tools when Python libraries unavailable

See how to install

Good for

  • Checking whether a PDF has the expected number of pages
  • Searching for required sections or terms in a PDF
  • Extracting text from a selected page range
  • Inspecting PDFs without Python PDF libraries

Files included (2)

  • SKILL.md5.0 KB
  • .skill_id34 B

SKILL.md (original)

Review the instructions the agent will receive before you install.

PDF Verification with Command-Line Tools

When verifying PDF files during task execution, Python libraries like PyPDF2 may not be available in the environment. This skill provides a reliable alternative using standard command-line tools from the poppler-utils package.

When to Use This Skill

  • Need to verify PDF page count
  • Need to inspect PDF text content
  • PyPDF2 or similar Python PDF libraries are unavailable
  • Working in minimal/containerized environments

Core Tools

1. pdfinfo - Extract PDF Metadata

Use pdfinfo to get page count and other metadata:

# Get full PDF info
pdfinfo document.pdf

# Get only page count
pdfinfo document.pdf | grep Pages

# Extract page count as a number
pdfinfo document.pdf | grep Pages | awk '{print $2}'

Key metadata fields:

  • Pages: Number of pages in the PDF
  • Title: Document title
  • Author: Document author
  • Creator: Application that created the PDF
  • Producer: Application that processed the PDF
  • CreationDate: When the PDF was created
  • ModDate: Last modification date

2. pdftotext - Extract Text Content

Use pdftotext to inspect the actual content of the PDF:

# Extract all text to stdout
pdftotext document.pdf -

# Extract text to a file
pdftotext document.pdf output.txt

# Extract text from specific page range
pdftotext -f 1 -l 3 document.pdf output.txt

# Preserve layout (rough formatting)
pdftotext -layout document.pdf output.txt

Verification Workflow

Step 1: Check Tool Availability

# Check if tools are installed
which pdfinfo
which pdftotext

# Or test with --help
pdfinfo --help 2>&1 | head -1

Step 2: Install if Needed

# Debian/Ubuntu
apt-get update && apt-get install -y poppler-utils

# RHEL/CentOS/Fedora
yum install -y poppler-utils
# or
dnf install -y poppler-utils

# macOS (with Homebrew)
brew install poppler

Step 3: Verify PDF Properties

# Verify page count matches expected
EXPECTED_PAGES=4
ACTUAL_PAGES=$(pdfinfo document.pdf | grep Pages | awk '{print $2}')

if [ "$ACTUAL_PAGES" -eq "$EXPECTED_PAGES" ]; then
    echo "✓ Page count verified: $ACTUAL_PAGES pages"
else
    echo "✗ Page count mismatch: expected $EXPECTED_PAGES, got $ACTUAL_PAGES"
fi

Step 4: Verify PDF Content

# Check for required sections/content
pdftotext document.pdf - | grep -i "checklist" && echo "✓ Contains checklist section"
pdftotext document.pdf - | grep -i "references" && echo "✓ Contains references section"

# Count occurrences of key terms
pdftotext document.pdf - | grep -ci "assessment"  # Case-insensitive count

Python Integration Example

import subprocess

def get_pdf_page_count(pdf_path):
    """Get page count using pdfinfo"""
    result = subprocess.run(
        ['pdfinfo', pdf_path],
        capture_output=True,
        text=True
    )
    for line in result.stdout.split('\n'):
        if line.startswith('Pages:'):
            return int(line.split(':')[1].strip())
    return None

def extract_pdf_text(pdf_path):
    """Extract all text from PDF using pdftotext"""
    result = subprocess.run(
        ['pdftotext', pdf_path, '-'],
        capture_output=True,
        text=True
    )
    return result.stdout

def verify_pdf(pdf_path, expected_pages, required_terms):
    """Verify PDF has expected page count and contains required terms"""
    # Check page count
    pages = get_pdf_page_count(pdf_path)
    if pages != expected_pages:
        return False, f"Expected {expected_pages} pages, got {pages}"
    
    # Check content
    text = extract_pdf_text(pdf_path).lower()
    missing = [term for term in required_terms if term.lower() not in text]
    
    if missing:
        return False, f"Missing terms: {missing}"
    
    return True, "PDF verification passed"

Common Use Cases

TaskCommand
Count pagespdfinfo file.pdf | grep Pages
Check if PDF has textpdftotext file.pdf - | head -5
Search for keywordpdftotext file.pdf - | grep -i "keyword"
Extract first pagepdftotext -f 1 -l 1 file.pdf out.txt
Get PDF titlepdfinfo file.pdf | grep Title

Troubleshooting

pdfinfo: command not found

  • Install poppler-utils (see Step 2 above)
  • Ensure PATH includes the installation directory

pdftotext returns empty output

  • PDF may be image-only (scanned) - requires OCR
  • PDF may be encrypted/password-protected
  • Try pdftotext -layout for better text extraction

Page count seems wrong

  • Some PDFs have blank pages counted
  • Verify with pdftotext to see actual content per page

Best Practices

  1. Always verify both structure and content - Page count alone doesn't guarantee content quality
  2. Use case-insensitive searches - Content may vary in capitalization
  3. Handle errors gracefully - Tools may fail on corrupted or encrypted PDFs
  4. Combine with file existence checks - Verify PDF exists before running tools

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

Prepare audio stems, the separate parts of a track, for mixing by matching their durations with silence, loops, or crossfades. Verify each generated and processed file before moving to the next production step.

  • Match audio parts with different durations
  • Extend drums and melodic parts using suitable methods
  • Check audio specifications before mixing
HKUDS/OpenSpace7.8KUpdated Aug 13, 2026

Produce audio in separate stems, meaning individual instrument tracks, and verify each output as you go. Align track lengths with silence, loops, or crossfades, then apply effects, mix a master, and package the files.

  • Align instrument tracks to a reference audio file
  • Choose how to extend tracks that are too short
  • Verify audio properties after generation and effects
HKUDS/OpenSpace7.8KUpdated Aug 13, 2026

Build serverless endpoints that relay external API requests for a dashboard while keeping API keys on the server. Includes Vercel examples for input checks, caching, cross-origin access, and consistent JSON responses.

  • Connect a dashboard to external APIs without exposing API keys
  • Create endpoints for stock quotes and news
  • Standardize API responses and error handling
HKUDS/OpenSpace7.8KUpdated Aug 13, 2026

Produce a master track and separate audio parts through a structured Python workflow. Apply filters and reverb, export WAV files with consistent settings, package them in a ZIP archive, and check that the deliverables meet the requested specifications.

  • Export a master track with separate audio parts
  • Apply filters and reverb to audio
  • Check duration and format across deliverables
HKUDS/OpenSpace7.8KUpdated Aug 13, 2026

Keep document creation moving when web searches and page retrieval repeatedly fail. The skill preserves the original task, uses the model’s existing knowledge, and clearly identifies information that could not be checked against external sources.

  • Continue drafting after repeated web retrieval failures
  • Preserve task requirements during network errors
  • Mark information that could not be externally verified
HKUDS/OpenSpace7.8KUpdated Aug 13, 2026

When Python execution repeatedly fails in execute_code_sandbox, use a file-based alternative: save the script, run it through the shell, and capture results or errors. The guidance covers paths, imports, timeouts, structured output, and optional cleanup.

  • Retry Python work through the shell after repeated sandbox failures
  • Run longer tasks with an adjusted timeout
  • Execute Python work that needs multiple files or system utilities
HKUDS/OpenSpace7.8KUpdated Aug 13, 2026

See all skills by HKUDS

Report a problem with this skill