DEV Community: Daniel Valentin Alonso Maqueira

Generate SEO Meta Tags for Any URL with One API Call

Daniel Valentin Alonso Maqueira — Sun, 26 Apr 2026 12:33:16 +0000

Writing meta titles and descriptions for hundreds of pages is the kind of work nobody enjoys. You have to read the page, summarize it in 60 characters, write a 155-character description, hit search intent, include the right keywords, and not sound like a robot. For one page it's fine. For a 200-page site? You'll cut corners and your SEO will pay for it.

So I built Origrid Meta Gen — an API that does it for you. One call per URL, optimized output, ready to paste.

How it works

Send a URL, get meta tags back:

curl -X POST https://api.origrid.io/v1/meta/generate \
  -H "Content-Type: application/json" \
  -d '{"url": "https://yourblog.com/post-about-rust"}'

Response:

{
  "title": "Why Rust's Borrow Checker Saved Our Production Database",
  "title_length": 56,
  "description": "How a small team rewrote a memory-leaking Node service in Rust, eliminated 3 OOM crashes per week, and learned to love the borrow checker.",
  "description_length": 142,
  "url": "https://yourblog.com/post-about-rust"
}

The API:

Fetches the URL server-side
Extracts the main content (no scripts, no nav, no footer noise)
Sends it to Claude Haiku with a tuned prompt
Returns title (max 60 chars) + description (max 160 chars)
Validates lengths before returning

Why not just use ChatGPT?

You absolutely can. But:

Length validation is a pain — ChatGPT regularly produces 70-character titles that get truncated in Google. The API enforces limits on the server side and retries if it goes over.
You have to fetch the page yourself — adds boilerplate (HTML parsing, content extraction, dealing with bot blocks).
Prompt engineering takes iteration — I spent days tuning the prompt to avoid clickbait, generic phrasing ("Discover the secrets of..."), and meta descriptions that just repeat the title.
Cost at scale — GPT-4 for 1000 pages is expensive. Haiku is 30x cheaper and just as good for this task.

The API wraps all of that into one HTTP call.

Real examples

I tested it on a mix of content types. These are unedited outputs:

Page type	Generated title	Description
Tech blog post	`How to Profile Memory in Bun: A Practical Guide`	`Profile your Bun applications using built-in heap snapshots, find memory leaks, and reduce RAM usage with three concrete debugging techniques.`
E-commerce product	`Black Wool Beanie - Hand-Knit in Portugal`	`Soft merino wool beanie hand-knit by artisans in Porto. One size fits most. Free shipping on orders over 50 EUR.`
Documentation	`PostgreSQL JSONB Indexing: Complete Reference`	`Master JSONB indexes in PostgreSQL with GIN, BTREE, and partial index strategies. Includes performance benchmarks and migration examples.`

All under length limits. None start with "Discover" or "Learn how to". All capture the actual page intent.

Bulk processing for site migrations

The most useful case is when you migrate a CMS or relaunch a site with no meta tags. Here's a Python script that processes a sitemap:

import requests
import xml.etree.ElementTree as ET
import time

API_URL = "https://origrid-meta-gen.p.rapidapi.com/v1/meta/generate"
HEADERS = {
    "X-RapidAPI-Key": "your_key",
    "Content-Type": "application/json"
}

def get_meta(url):
    resp = requests.post(API_URL, headers=HEADERS, json={"url": url})
    return resp.json()

# Parse sitemap.xml
sitemap = requests.get("https://yoursite.com/sitemap.xml").text
root = ET.fromstring(sitemap)
ns = {"sm": "http://www.sitemaps.org/schemas/sitemap/0.9"}
urls = [el.text for el in root.findall(".//sm:loc", ns)]

# Generate meta for each
results = []
for url in urls:
    try:
        meta = get_meta(url)
        results.append({"url": url, **meta})
        print(f"OK: {meta['title']}")
    except Exception as e:
        print(f"FAIL: {url} - {e}")
    time.sleep(0.5)  # be nice to your rate limit

# Now you have a CSV ready to bulk-update your CMS
import csv
with open("meta_tags.csv", "w") as f:
    w = csv.DictWriter(f, fieldnames=["url", "title", "description"])
    w.writeheader()
    for r in results:
        w.writerow({"url": r["url"], "title": r["title"], "description": r["description"]})

200 pages = 200 API calls + 100 seconds of waiting + a CSV ready to import. Beats the 8 hours of manual work.

When it won't work

The API can't help if:

The page is behind auth (it can't log in for you)
The page is JavaScript-rendered with no SSR (it sees an empty shell)
The page is mostly images with no text content

For SSR'd pages with real text, it works on the first try about 95% of the time in my testing.

Try it

Origrid Meta Gen on RapidAPI — free tier, no credit card needed.

Or test directly:

curl -X POST https://api.origrid.io/v1/meta/generate \
  -H "Content-Type: application/json" \
  -d '{"url": "https://en.wikipedia.org/wiki/Rust_(programming_language)"}'

Built with FastAPI + Claude Haiku. Full OpenAPI docs at api.origrid.io/docs.

What sites would you bulk-process if it took 1 second per page? Curious about CMS plugin ideas — drop a comment.

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:

curl -X POST https://api.origrid.io/v1/alt/generate \
  -H "Content-Type: application/json" \
  -d '{"image_url": "https://picsum.photos/id/42/800/600"}'

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"]

# Fetch page and find images without 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}")

# Save the updated HTML
with open("updated_page.html", "w") as f:
    f.write(str(soup))

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, no setup.

Or test directly:

# Try with any public image URL
curl -X POST https://api.origrid.io/v1/alt/generate \
  -H "Content-Type: application/json" \
  -d '{"image_url": "https://picsum.photos/id/237/800/600"}'

The API also supports JPEG, PNG, WebP, and GIF. Full OpenAPI docs at api.origrid.io/docs.

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 fines for non-compliance can reach €20 million or 4% of global revenue, whichever is higher. Meta got hit for €1.2 billion in 2023. Even small companies have been fined six figures for storing emails or phone numbers without proper safeguards. The "we'll add PII detection later" excuse is a liability time bomb.

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

Send this:

curl -X POST https://api.origrid.io/v1/pii/scan \
  -H "Content-Type: application/json" \
  -d '{"text": "Email john@test.com, call +34 612 345 678, card 4111-1111-1111-1111"}'

Get this:

{
  "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

Or hit the API directly:

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, deployed on Docker. The full OpenAPI spec with examples is at api.origrid.io/docs.

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