DEV Community: Daniel Valentin Alonso Maqueira

Add WCAG Alt Text to Every Image with One API Call

Daniel Valentin Alonso Maqueira — Fri, 03 Apr 2026 12:31:38 +0000

If your site has images without alt text, you have two problems:

Screen readers can't describe them to visually impaired users
You might get sued -- ADA lawsuits over web accessibility hit record numbers in 2025

Manually writing alt text for hundreds of images is tedious. So I built an API that does it with one call per image.

The API

Send an image URL, get WCAG 2.1 compliant alt text back:

import requests

response = requests.post(
    "https://origrid-alt-text.p.rapidapi.com/v1/alt/generate",
    headers={
        "X-RapidAPI-Key": "YOUR_KEY",
        "Content-Type": "application/json"
    },
    json={"image_url": "https://picsum.photos/id/42/800/600"}
)
print(response.json())

Response:

{
  "alt_text": "Two teal coffee cups on saucers and a smartphone on a rustic wooden table in a cafe",
  "alt_text_length": 84,
  "wcag_compliant": true
}

That's it. No complex setup, no image upload, no training. Send a URL, get alt text.

What makes it WCAG compliant

The API follows WCAG 2.1 Success Criterion 1.1.1:

Max 125 characters -- screen readers handle short alt text better
Describes content, not decoration -- "sunset over beach" not "beautiful photo"
Never starts with "Image of" or "Photo of" -- screen readers already announce it's an image
Specific -- mentions subjects, actions, colors, and setting

The wcag_compliant boolean in the response tells you programmatically whether the generated text meets the criteria.

Real examples

Image	Generated alt text
Beach sunset	`Golden sunset over sandy beach with turquoise waters and palm tree silhouettes`
Coffee shop	`Two teal coffee cups on saucers and a smartphone on a rustic wooden table in a cafe`
Dog portrait	`A black labrador puppy sits on a wooden floor, looking up with big dark eyes`
Mountain landscape	`Mountain lake surrounded by pine trees with snow-capped peaks reflected in calm blue water`

All under 125 characters, all descriptive, all screen-reader friendly.

Bulk processing with Python

Here's how to add alt text to every image on a page:

import requests
from bs4 import BeautifulSoup

RAPIDAPI_KEY = "your_key"
HEADERS = {
    "X-RapidAPI-Key": RAPIDAPI_KEY,
    "Content-Type": "application/json"
}

def get_alt_text(image_url):
    resp = requests.post(
        "https://origrid-alt-text.p.rapidapi.com/v1/alt/generate",
        headers=HEADERS,
        json={"image_url": image_url}
    )
    return resp.json()["alt_text"]

page = requests.get("https://yoursite.com/page")
soup = BeautifulSoup(page.text, "html.parser")

for img in soup.find_all("img"):
    if not img.get("alt"):
        alt = get_alt_text(img["src"])
        img["alt"] = alt
        print(f"Added: {alt}")

Why not use ChatGPT directly?

You could, but:

ChatGPT doesn't enforce 125 char limit -- you'd need to prompt-engineer and validate
No wcag_compliant flag -- you'd build your own validation
API integration is messy -- ChatGPT's API isn't designed for single-purpose endpoints
Cost -- GPT-4 vision is expensive for bulk image processing

Origrid Alt Text is a purpose-built endpoint. One call, one response, validated output.

Try it

Origrid Alt Text on RapidAPI -- free tier (50 images/month), no credit card required.

Full API docs and test endpoint available directly on the RapidAPI listing.

How do you handle alt text at scale? I'm curious about CMS integrations people would find useful. Drop a comment.

I Built a PII Detection API with Zero AI Cost (Pure Regex)

Daniel Valentin Alonso Maqueira — Fri, 03 Apr 2026 12:31:00 +0000

Most PII detection tools charge per API call because they run your text through an LLM. But for detecting structured patterns like emails, phone numbers, and credit cards, you don't need AI at all.

I built Origrid PII Detect -- a PII scanning API that uses pure regex pattern matching. Zero LLM calls, zero AI cost, sub-500ms response times.

The problem

If you're building any app that handles user text (forms, comments, chat, logs), you probably need to check for accidentally exposed personal data before storing or forwarding it. GDPR requires it. Common sense demands it.

The existing options are:

Microsoft Presidio -- powerful but requires self-hosting a full NLP pipeline
AWS Comprehend -- great but $0.01+ per request adds up fast
Google DLP -- enterprise pricing, enterprise complexity

For most use cases, you don't need NLP. Emails look like emails. Phone numbers look like phone numbers. Credit cards follow the Luhn algorithm.

The approach: regex with smart deduplication

The API detects 6 entity types using pre-compiled regex patterns:

Entity	How it's detected
Email	RFC 5322 simplified pattern
Phone	International formats (US, EU, UK, LATAM)
Credit card	Visa/MC/Amex/Discover patterns + Luhn validation
SSN	US format XXX-XX-XXXX with range validation
IBAN	European format with country code prefix
IP address	IPv4 with octet range validation

Luhn validation for credit cards

This is the key differentiator from naive regex. A pattern like 4111-1111-1111-1111 matches the Visa format, but we also run Luhn's algorithm to verify it's a mathematically valid card number:

def _luhn_check(number: str) -> bool:
    digits = [int(d) for d in number if d.isdigit()]
    if len(digits) < 13:
        return False
    checksum = 0
    for i, d in enumerate(reversed(digits)):
        if i % 2 == 1:
            d *= 2
            if d > 9:
                d -= 9
        checksum += d
    return checksum % 10 == 0

This eliminates false positives from random number sequences that happen to match card formats.

Smart deduplication

When patterns overlap (e.g., a phone number inside an IBAN), the API deduplicates by priority. Credit cards and SSNs have highest priority since they're the most sensitive.

What you get back

Example response:

{
  "pii_found": true,
  "entity_count": 3,
  "entities": [
    {"type": "email", "value": "john@test.com", "start": 6, "end": 19, "confidence": 1.0},
    {"type": "phone", "value": "+34 612 345 678", "start": 26, "end": 41, "confidence": 1.0},
    {"type": "credit_card", "value": "4111-1111-1111-1111", "start": 48, "end": 67, "confidence": 1.0}
  ],
  "redacted_text": "Email [EMAIL], call [PHONE], card [CREDIT_CARD]",
  "risk_level": "high"
}

Key features:

Exact positions (start/end) so you can highlight or mask in your UI
Redacted text ready to store safely
Risk level (high = credit cards or SSNs found)

Performance

Because there's no AI model in the loop:

Latency: ~100-400ms (network overhead, not compute)
Cost per call: $0.00 (no LLM tokens)
Reliability: deterministic -- same input always produces same output

When you DO need AI

Regex won't catch:

Names (without a dictionary)
Street addresses (too many formats)
Context-dependent PII ("my birthday is next Thursday")

For those, you need an LLM layer. I'm planning a "deep scan" mode for v2 that adds LLM analysis on top of regex. But for 80% of compliance use cases, regex covers what you need.

Try it free

The API is live on RapidAPI with a free tier (50 requests/month):

Origrid PII Detect on RapidAPI

import requests

response = requests.post(
    "https://origrid-pii-detect.p.rapidapi.com/v1/pii/scan",
    headers={
        "X-RapidAPI-Key": "YOUR_KEY",
        "Content-Type": "application/json"
    },
    json={"text": "Contact sarah@company.com or 555-123-4567"}
)

data = response.json()
print(data["redacted_text"])
# "Contact [EMAIL] or [PHONE]"

Built with FastAPI. Full OpenAPI docs available on the RapidAPI listing.

What PII patterns would you add? I'm considering passport numbers and driver's license formats for v2. Let me know in the comments.