DEV Community: Daniel Igel

Auto-generate Open Graph preview images for any URL with the Website Screenshot API

Daniel Igel — Sat, 08 Aug 2026 13:00:02 +0000

Generating Open Graph preview images usually means running Playwright or Puppeteer on your own server — browser dependencies, a launch pool, queue management, and memory limits before you've written a single line of product logic.

One GET captures a screenshot of any public URL and returns it as base64 or raw binary:

curl --request GET \
  --url 'https://api.sprytools.com/v1/screenshot/api/v1/screenshot?url=https://example.com&format=png&viewport=desktop&fullPage=false&blockAds=true' \
  --header 'x-api-key: YOUR_API_KEY'

You get { success, format, width, height, fullPage, image, size } where image is a base64-encoded PNG you can drop straight into an <img> src or write to a file.

For OG images the standard canvas is 1200 × 630 — pass a custom viewport instead of the desktop preset:

const res = await fetch('https://api.sprytools.com/v1/screenshot/api/v1/screenshot', {
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    'x-api-key': process.env.SPRYTOOLS_API_KEY,
  },
  body: JSON.stringify({
    url: 'https://yourblog.com/posts/my-article',
    viewport: { width: 1200, height: 630 },
    format: 'png',
    blockAds: true,
    responseType: 'base64',
  }),
});
const { image } = await res.json();
// image is ready to store in S3, Cloudflare R2, or serve from a Next.js route handler

Need to wait for a React or Vue page to finish hydrating before the screenshot fires? Add waitForSelector: '#hero-title' and the API holds until that element appears (up to the timeout you set, max 30 000 ms). format accepts png, jpeg, and webp; darkMode: true switches the OS colour scheme before capture.

Free key: 100 calls/day, no credit card — https://sprytools.com/apis/screenshot/

Do you generate OG images at build time or on-demand — and has one approach caused you more headaches than the other?

Show prices in the user's local currency: live ECB exchange rates in your Next.js app

Daniel Igel — Fri, 07 Aug 2026 13:00:01 +0000

Showing prices in the user's local currency sounds simple until you hit three separate problems: sourcing reliable exchange rates, avoiding stale conversions in a cached SSR layer, and keeping your API key off the client.

One GET to /api/v1/convert handles the conversion — official ECB (European Central Bank) rates, cached hourly:

curl --request GET \
  --url 'https://api.sprytools.com/v1/currency/api/v1/convert?from=USD&to=EUR&amount=99.99' \
  --header 'x-api-key: YOUR_API_KEY'

You get back { "from", "to", "amount", "result", "rate" } — the converted amount and the exchange rate used, rounded to six decimal places.

In a Next.js Server Component, set revalidate = 3600 to align with the API's 1-hour ECB cache — rates stay fresh without a per-request fetch:

// app/products/[id]/page.jsx
export const revalidate = 3600;

async function localPrice(usdAmount, targetCurrency) {
  const res = await fetch(
    `https://api.sprytools.com/v1/currency/api/v1/convert?from=USD&to=${targetCurrency}&amount=${usdAmount}`,
    { headers: { 'x-api-key': process.env.SPRYTOOLS_API_KEY } }
  );
  const data = await res.json();
  return data.result;
}

Need to know which currencies are available? GET /api/v1/currencies returns the sorted list. Want a price-history chart? GET /api/v1/history?currency=USD&days=30 gives you up to 90 days of daily ECB rates.

Free key: 100 calls/day, no credit card — https://sprytools.com/apis/currency/

Which currency-related feature do your users ask for most?

Build a customer feedback sentiment dashboard in Node.js — no ML setup, just a REST API call

Daniel Igel — Thu, 06 Aug 2026 13:00:01 +0000

Running sentiment over customer reviews or support tickets by hand doesn't scale. Spinning up your own ML pipeline — model download, inference server, GPU costs — is overkill for most products.

One POST gives you sentiment, a confidence score, and an explanation in JSON:

curl --request POST \
  --url 'https://api.sprytools.com/v1/ai/api/v1/sentiment' \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: YOUR_API_KEY' \
  --data '{"text":"The onboarding flow is confusing and support was slow to respond."}'

Response: { "sentiment": "negative", "score": 0.87, "explanation": "…" }. Score is 0.0–1.0 (1.0 = strongest polarity), sentiment is one of "positive", "negative", or "neutral".

To build a simple feedback dashboard, batch your review rows and aggregate by sentiment:

async function scoreReview(text) {
  const res = await fetch('https://api.sprytools.com/v1/ai/api/v1/sentiment', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': process.env.SPRYTOOLS_API_KEY,
    },
    body: JSON.stringify({ text }),
  });
  return res.json(); // { sentiment, score, explanation }
}

const scores = await Promise.all(reviews.map(r => scoreReview(r.text)));
const tally = scores.reduce((acc, s) => {
  acc[s.sentiment] = (acc[s.sentiment] ?? 0) + 1;
  return acc;
}, {});
// { positive: 42, neutral: 11, negative: 8 }

The same API covers four more operations with no additional key or infra: keyword extraction (/api/v1/keywords → [{ word, score, frequency }]), named-entity recognition (/api/v1/entities → types: PERSON, LOCATION, ORGANIZATION, DATE, OTHER), custom category classification (/api/v1/classify → pass your own categories[]), and summarization (/api/v1/summarize → { summary, sentences[], wordCount }) — all POST, all under the same /v1/ai/ prefix. Max input is 16 000 characters per request.

Free key: 100 calls/day, no credit card — https://sprytools.com/apis/ai/

Do you run sentiment analysis in production today, and what's powering it?

Cut signup spam: 3-layer email validation with RFC syntax, MX check and disposable detection

Daniel Igel — Wed, 05 Aug 2026 13:00:02 +0000

Most signup forms accept anything that looks like an email. That costs you: bounced sends tank your deliverability, disposable addresses inflate your free tier, and role addresses like admin@example.com rarely convert.

Three layers catch what a regex alone misses. One GET returns all of them:

curl --request GET \
  --url 'https://api.sprytools.com/v1/email-validation/api/v1/validate?email=user@yopmail.com' \
  --header 'x-api-key: YOUR_API_KEY'

The response tells you exactly why an address failed:

{
  "email": "user@yopmail.com",
  "valid": false,
  "reason": "disposable_email",
  "checks": { "syntax": true, "mxRecords": true, "disposable": true }
}

reason is one of invalid_syntax, no_mx_records, or disposable_email. Valid addresses also return roleBased, freeProvider, and a typo suggestion — so you can surface a polite correction before the user submits (gnail.com → gmail.com).

Batch-validate up to 100 addresses in one call by POSTing to the same path:

const res = await fetch(
  'https://api.sprytools.com/v1/email-validation/api/v1/validate',
  {
    method: 'POST',
    headers: {
      'x-api-key': process.env.SPRYTOOLS_API_KEY,
      'content-type': 'application/json',
    },
    body: JSON.stringify({ emails: importedList }),
  }
);
const { results, summary } = await res.json();
// summary: { total, valid, invalid }

No ML model, no third-party lookups beyond DNS — syntax is a pure RFC 5322 regex, MX is a standard DNS check, disposable uses a curated blocklist.

Free key: 100 calls/day, no credit card — https://sprytools.com/apis/email-validation/

What's your current approach for email validation at signup — client-side regex only, or do you also check MX and disposable providers?

3 ways to use IP geolocation in your web app: personalization, server-side detection, and log enrichment

Daniel Igel — Tue, 04 Aug 2026 13:00:01 +0000

IP geolocation shows up in three distinct scenarios: personalizing content for a visitor's country, detecting locale in server-side middleware without touching the frontend, and enriching analytics logs with geographic context. All three use the same API.

1. Content personalization — resolve country and timezone, then adapt the response:

const res = await fetch(
  `https://api.sprytools.com/v1/geo/api/v1/geo?ip=${clientIp}`,
  { headers: { 'x-api-key': process.env.SPRYTOOLS_API_KEY } }
);
const { countryCode, timezone } = await res.json();
// redirect /de for DE, show timezone-aware timestamps, etc.

Fields: country, countryCode, region, city, latitude, longitude, timezone, isp, as.

2. Server-side locale detection — read the caller's IP from the proxy header in your own middleware and pass it explicitly:

// Next.js middleware / Express before-routes / edge function
const clientIp = req.headers.get('x-forwarded-for')?.split(',')[0].trim();

const { countryCode } = await fetch(
  `https://api.sprytools.com/v1/geo/api/v1/geo?ip=${clientIp}`,
  { headers: { 'x-api-key': process.env.SPRYTOOLS_API_KEY } }
).then(r => r.json());

That gives you the country before rendering, without pulling a geo database into your own build.

3. Batch log enrichment — resolve up to 50 IPs in one request to annotate event logs without N+1 calls:

const { results } = await fetch('https://api.sprytools.com/v1/geo/api/v1/geo/batch', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': process.env.SPRYTOOLS_API_KEY,
  },
  body: JSON.stringify({ ips: logEntries.map(e => e.ip) }),
}).then(r => r.json());

Lookups run against a locally hosted MaxMind GeoLite2-City database — no per-call latency from an external provider.

Free key: 100 calls/day, no credit card — https://sprytools.com/apis/geo/

Which of these three use cases first pushed you to add geolocation to your app?

How to add EU VAT number validation to your Stripe checkout in under 30 minutes

Daniel Igel — Mon, 03 Aug 2026 13:00:01 +0000

EU B2B SaaS with Stripe has a common requirement: validate the customer's VAT number before finalizing the checkout so you can apply the correct tax rate — or zero-rate cross-border sales. Stripe itself does not verify against VIES; that check is your responsibility.

GET /api/v1/validate?vat=DE123456789 hits the EU's official VIES database, caches results for 1 hour, and returns valid, name, and address for the business — everything you need to decide the tax treatment:

curl --request GET \
  --url 'https://eu-vat-number-validator-api.p.rapidapi.com/api/v1/validate?vat=DE123456789' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: eu-vat-number-validator-api.p.rapidapi.com'

Wire it into a preflight before your PaymentIntent:

const res = await fetch(
  'https://eu-vat-number-validator-api.p.rapidapi.com/api/v1/validate?vat='
    + encodeURIComponent(vatInput),
  {
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'eu-vat-number-validator-api.p.rapidapi.com',
    },
  }
);
const { valid, name, address } = await res.json();
if (!valid) return res.status(422).json({ error: 'Invalid VAT number' });
// Apply zero-rate and pre-fill billing details from `name` / `address`

POST /api/v1/validate/batch accepts up to 10 numbers in one request — handy for onboarding flows where customers import CRM exports with existing VAT data. Covers all 27 EU member states plus Northern Ireland (XI country code).

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/eu-vat-number-validator-api

Are you handling EU VAT zero-rating automatically today, or still doing it manually after checkout?

5 real-world IBAN validation use cases in SaaS apps — from checkout forms to invoice generation

Daniel Igel — Sun, 02 Aug 2026 13:00:00 +0000

IBAN validation shows up in more places than most developers expect. Here are five SaaS scenarios where GET /api/v1/validate and POST /api/v1/validate/batch cover the requirement without adding a banking SDK.

1. Checkout forms. Validate on blur before the user submits — reject typos instantly, not after a failed payment attempt.

2. Invoice generation. Before writing a payout IBAN to your database, run a MOD-97 check against ISO 13616 specs for 85 countries. A stored invalid IBAN means a failed wire later.

3. Bulk payment imports. Accounts teams upload CSV files with hundreds of IBANs. Send the whole batch in one shot — up to 100 per request — and get validCount, invalidCount, and per-row results back together:

curl --request POST \
  --url 'https://iban-validator-parser-api.p.rapidapi.com/api/v1/validate/batch' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: iban-validator-parser-api.p.rapidapi.com' \
  --header 'content-type: application/json' \
  --data '{"ibans":["DE89370400440532013000","GB29NWBK60161331926819","INVALID"]}'

4. B2B onboarding. After validation, call GET /api/v1/parse?iban=... to extract bankCode, accountNumber, countryName, and formattedIBAN — pre-fill those fields in the UI so the user can verify:

const res = await fetch(
  'https://iban-validator-parser-api.p.rapidapi.com/api/v1/parse?iban=' + encodeURIComponent(iban),
  {
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'iban-validator-parser-api.p.rapidapi.com',
    },
  }
);
const { bankCode, accountNumber, countryName, formattedIBAN } = await res.json();

5. Open Banking integrations. Country-specific IBAN length rules vary — GET /api/v1/countries returns the expected length and format for all 85 supported countries, useful for front-end format hints before the user even finishes typing.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/iban-validator-parser-api

Which of these scenarios hit closest to home for you — are you validating at input time, at import, or at payout?

Measure reading ease and extract keywords from any text — Flesch-Kincaid and more via REST API

Daniel Igel — Sat, 01 Aug 2026 13:00:02 +0000

Adding readability scoring to your app usually means pulling in a full NLP library — Flesch-Kincaid alone requires syllable counting, sentence splitting, and word frequency logic. The Text Stats & Readability API bundles all of it in a pure Node.js REST service with no ML, no external model calls.

POST /api/v1/analyze returns everything in one shot — Flesch Reading Ease, Flesch-Kincaid Grade Level, top keywords with frequency and density, plus word/sentence/paragraph counts:

curl --request POST \
  --url 'https://text-stats-readability-api.p.rapidapi.com/api/v1/analyze' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: text-stats-readability-api.p.rapidapi.com' \
  --header 'content-type: application/json' \
  --data '{"text": "Your article or blog post goes here.", "topN": 10}'

The response includes fleschReadingEase (0–100, higher = easier), fleschKincaidGrade (US school grade level), and interpretation ("Easy", "Standard", "Difficult", etc.). The topKeywords array gives each keyword's count and density percentage after stop-word filtering.

const res = await fetch(
  'https://text-stats-readability-api.p.rapidapi.com/api/v1/analyze',
  {
    method: 'POST',
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'text-stats-readability-api.p.rapidapi.com',
      'content-type': 'application/json',
    },
    body: JSON.stringify({ text: articleBody, topN: 10 }),
  }
);
const { fleschReadingEase, fleschKincaidGrade, topKeywords } = await res.json();

Need just one metric? POST /api/v1/readability returns Flesch scores only; POST /api/v1/keywords returns keywords only; POST /api/v1/summary/stats returns word, sentence, paragraph, and character counts.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/text-stats-readability-api

Do you currently gate content on a readability target, or do you use readability scores more as a post-publish signal?

Convert HTML to clean Markdown via REST API — perfect for content migration and web scraping

Daniel Igel — Fri, 31 Jul 2026 13:00:01 +0000

Scraping a webpage or migrating CMS content means you usually end up with raw HTML — but your pipeline wants clean Markdown for LLM prompts, static-site generators, or readable diffs. Writing a reliable HTML-to-Markdown converter yourself means wrestling with nested tags, code blocks, tables, and <script> noise you don't want in the output.

One POST turns any HTML string into clean Markdown:

curl --request POST \
  --url 'https://html-to-markdown-converter-api.p.rapidapi.com/api/v1/convert' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: html-to-markdown-converter-api.p.rapidapi.com' \
  --header 'Content-Type: application/json' \
  --data '{"html":"<h1>Hello</h1><p>World</p>","options":{"clean":true}}'

You get back { markdown, inputLength, outputLength }. The clean: true option strips <script>, <style>, <iframe>, and ad tags before conversion — exactly what you need when scraping live pages.

Need to convert an entire URL without fetching it yourself? Use the preview endpoint:

const res = await fetch(
  'https://html-to-markdown-converter-api.p.rapidapi.com/api/v1/preview?url=' +
    encodeURIComponent('https://example.com'),
  {
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'html-to-markdown-converter-api.p.rapidapi.com',
    },
  }
);
const { markdown } = await res.json();

For bulk jobs, POST /api/v1/convert/batch accepts up to 10 items in one request. Powered by turndown (MIT) — no external API calls, no rate-limited third-party service.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/html-to-markdown-converter-api

What's your go-to use case for converting HTML to Markdown — LLM input prep, CMS migration, or something else?

Generate and validate passwords via REST API — CSPRNG, entropy scoring, and Diceware passphrases

Daniel Igel — Thu, 30 Jul 2026 13:10:55 +0000

Most auth flows generate passwords client-side, which means exposing the CSPRNG to the browser. Server-side generation via a one-call API keeps the randomness off-device and lets you enforce policies without duplicating logic across platforms.

One GET returns a cryptographically secure password:

curl "https://password-generator-strength-checker-api.p.rapidapi.com/api/v1/generate?length=20&symbols=true&excludeAmbiguous=true" \
  -H "x-rapidapi-key: YOUR_RAPIDAPI_KEY" \
  -H "x-rapidapi-host: password-generator-strength-checker-api.p.rapidapi.com"

The response includes the password, its length, entropy in bits, and which character sets were active. excludeAmbiguous=true strips characters like 0, O, l, and 1 that look identical in most fonts — useful for passwords users will ever read aloud or type manually.

To score a candidate password your users submit, POST to /check:

const res = await fetch(
  'https://password-generator-strength-checker-api.p.rapidapi.com/api/v1/check',
  {
    method: 'POST',
    headers: {
      'content-type': 'application/json',
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'password-generator-strength-checker-api.p.rapidapi.com',
    },
    body: JSON.stringify({ password: 'hunter2' }),
  }
);
const { score, strength, entropy, crackTime, weaknesses } = await res.json();
// score: 0–100, strength: "Very Weak" | "Weak" | "Fair" | "Strong" | "Very Strong"

The checker detects common passwords, keyboard walks, sequential characters, and repeated patterns — returns a 0–100 score, entropy in bits, and a human-readable crack-time estimate.

Need passphrases instead? GET /api/v1/passphrase?words=4&separator=- returns a Diceware-style phrase. For bulk generation — onboarding flows, test fixtures — POST /api/v1/bulk accepts up to 100 passwords in one request. All endpoints run on Node.js built-in crypto, no third-party dependencies.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/password-generator-strength-checker-api

Do you enforce password strength at the API layer or leave that to the frontend?

Generate EAN-13, Code 128 and QR barcodes via REST API — PNG and SVG output, no library needed

Daniel Igel — Wed, 29 Jul 2026 13:00:01 +0000

Adding barcodes to an app usually means installing a native library, dealing with font paths, or spinning up a separate service. For a shipping label, product catalog, or inventory export, that setup overhead isn't worth it.

One GET returns a barcode image as raw PNG or SVG bytes:

curl -o barcode.png \
  "https://barcode-generator-api4.p.rapidapi.com/api/v1/barcode?data=012345678905&type=EAN13&format=png" \
  -H "x-rapidapi-key: YOUR_RAPIDAPI_KEY" \
  -H "x-rapidapi-host: barcode-generator-api4.p.rapidapi.com"

The response is the image directly — write it to a file, stream it into an <img src>, or pipe it into your PDF renderer. Pass format=svg for a scalable vector.

For extra control — scale, height, or hiding the human-readable text — switch to the POST endpoint:

const res = await fetch(
  'https://barcode-generator-api4.p.rapidapi.com/api/v1/barcode',
  {
    method: 'POST',
    headers: {
      'content-type': 'application/json',
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'barcode-generator-api4.p.rapidapi.com',
    },
    body: JSON.stringify({ type: 'QR', data: 'https://example.com', format: 'svg', scale: 4 }),
  }
);
const svg = await res.text(); // image/svg+xml

Supported types: EAN-13, EAN-8, UPC-A, UPC-E, Code 128, Code 39, Code 93, ITF-14, DataMatrix, QR — powered by bwip-js server-side, no native bindings, no font files to manage.

Need bulk generation? POST /api/v1/barcode/batch accepts up to 20 items and returns each barcode as a base64-encoded image in one JSON response — useful for pre-generating product label sheets.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/barcode-generator-api4

Which barcode format does your project use most — linear (EAN/Code 128) or 2D (QR/DataMatrix)?

Check if an IP is blacklisted across 7 DNSBL sources — free REST API, no setup required

Daniel Igel — Tue, 28 Jul 2026 13:00:02 +0000

Implementing DNSBL lookups from scratch means coding DNS reverse-address queries, querying multiple blacklist zones in parallel, and handling NXDOMAIN vs. real errors without misreporting a clean IP as blacklisted. The IP Reputation & Blacklist Checker API wraps all of that in a single GET — pure Node.js dns/promises, no external API key, seven DNSBL sources in one call.

GET /api/v1/check?ip=<ip> queries Spamhaus ZEN, Barracuda, SORBS, SpamCop, Spamhaus SBL, Spamhaus XBL, and UCEPROTECT Level 1 simultaneously and returns a listed boolean, a listedCount, and a per-blacklist breakdown:

curl --request GET \
  --url 'https://ip-reputation-blacklist-checker-api.p.rapidapi.com/api/v1/check?ip=1.2.3.4' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: ip-reputation-blacklist-checker-api.p.rapidapi.com'

Each entry in blacklists contains name, zone, listed (true/false/null for failed lookups), and returnCodes — the raw DNS A-record codes that each DNSBL returns when an IP is listed.

const res = await fetch(
  'https://ip-reputation-blacklist-checker-api.p.rapidapi.com/api/v1/check?ip=1.2.3.4',
  { headers: { 'x-rapidapi-key': process.env.RAPIDAPI_KEY, 'x-rapidapi-host': 'ip-reputation-blacklist-checker-api.p.rapidapi.com' } }
);
const { listed, listedCount, blacklists } = await res.json();

For bulk checks, POST /api/v1/check/batch accepts an ips array (max 10) and returns one result object per IP — useful for scrubbing a list of sender IPs before a transactional mail run. Results are cached for 5 minutes, and GET /api/v1/lists returns the full list of active DNSBL zones if you need to inspect what's being queried.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/ip-reputation-blacklist-checker-api

Do you run DNSBL checks on inbound IPs, outbound sender IPs, or both?