DEV Community: Daniel Igel

Add JSON-LD structured data in 10 minutes to get cited by AI search

Daniel Igel — Mon, 27 Jul 2026 13:00:02 +0000

AI search engines extract structured signals, not raw text. Without JSON-LD, a crawler guesses your page type, author, and topic from prose — which makes citations inconsistent and attribution wrong. With the right markup it takes 10 minutes to fix.

Three Schema.org types cover most developer pages:

Organization — who publishes this. Required for brand attribution in AI-generated answers.
Article with datePublished/dateModified — marks content as citable with a freshness signal AI engines weigh heavily.
FAQPage or HowTo — the highest-value signal: Q&A markup maps directly to how AI assistants answer questions, and these blocks get quoted disproportionately.

Minimal JSON-LD for a blog or docs page

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "name": "Your Brand",
      "url": "https://example.com"
    },
    {
      "@type": "Article",
      "headline": "Your page title",
      "author": { "@type": "Organization", "name": "Your Brand" },
      "datePublished": "2026-01-01",
      "dateModified": "2026-07-11"
    }
  ]
}
</script>

For Q&A content, append a FAQPage block — each question + answer pair becomes a separately citable passage.

Check all five JSON-LD signals in one call

curl -X POST https://citeready-api.sprytools.com/v1/audit \
  -H "content-type: application/json" \
  -d '{"url":"https://yoursite.com"}'

The structured_data category reports jsonld_present, jsonld_valid, jsonld_org_or_website, jsonld_content_type, and jsonld_faq_howto — pass/warn/fail with the exact fix to apply for each.

const res = await fetch('https://citeready-api.sprytools.com/v1/audit', {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ url: 'https://yoursite.com' }),
});
const { categories } = await res.json();
const sd = categories.find(c => c.id === 'structured_data');
console.log(sd.score, sd.checks);

Free at https://citeready.sprytools.com — 3 checks/day, no signup.

Which Schema.org type were you missing when you first ran the audit?

Detect the language of any text in 187 languages — no ML model, no billing

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

Language detection sounds simple until you try to build it yourself: ML models need a Python runtime or GPU, cloud translation APIs charge per character and require billing setup, and browser-side heuristics break on short strings or multilingual input.

One POST detects the language of any text across 187 languages — no ML server, no third-party API key, no outbound calls from the server:

curl --request POST \
  --url 'https://language-detection-api7.p.rapidapi.com/api/v1/detect' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: language-detection-api7.p.rapidapi.com' \
  --header 'content-type: application/json' \
  --data '{"text":"Bonjour, comment allez-vous?"}'

Returns language (ISO 639-1 code), languageName, confidence, and an alternatives array for ambiguous input — helpful when text is short or code-mixed.

const { language, languageName, confidence } = await fetch(
  'https://language-detection-api7.p.rapidapi.com/api/v1/detect',
  {
    method: 'POST',
    headers: {
      'content-type': 'application/json',
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'language-detection-api7.p.rapidapi.com',
    },
    body: JSON.stringify({ text: userInput }),
  }
).then(r => r.json());

if (language === 'de') serveGermanContent();

Need to classify a list of strings? POST /api/v1/detect/batch accepts up to 20 texts in one call. GET /api/v1/languages returns all 187 supported languages with ISO codes — useful for building a language picker. Powered by franc (MIT licence), a pure statistical n-gram model; no GPU, no Python, no billing surprises.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/language-detection-api7

Do you detect user language from Accept-Language headers, text content, or a combination of both?

Mortgage, loan and compound interest calculations via REST API — no spreadsheet needed

Daniel Igel — Sat, 25 Jul 2026 13:00:01 +0000

Building financial calculators means re-implementing the same amortization formulas in every project. The Financial Calculator API handles loan payments, mortgage amortization, compound interest, savings goals, and ROI via plain POST requests — no spreadsheet embedded in your backend.

POST /api/v1/loan takes principal, annualRate (as a percentage, e.g. 6.5), and months, and returns a monthly payment, total interest, and a full amortization schedule:

curl --request POST \
  --url 'https://financial-calculator-api2.p.rapidapi.com/api/v1/loan' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: financial-calculator-api2.p.rapidapi.com' \
  --header 'content-type: application/json' \
  --data '{"principal": 20000, "annualRate": 6.5, "months": 48}'

Response includes monthlyPayment: 474.3, totalInterest: 2766.36, and a schedule array with per-month payment, principal, interest, and remaining balance.

const res = await fetch(
  'https://financial-calculator-api2.p.rapidapi.com/api/v1/loan',
  {
    method: 'POST',
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'financial-calculator-api2.p.rapidapi.com',
      'content-type': 'application/json',
    },
    body: JSON.stringify({ principal: 20000, annualRate: 6.5, months: 48 }),
  }
);
const { monthlyPayment, totalInterest, schedule } = await res.json();

For mortgages, POST /api/v1/mortgage adds an optional extraPayments array — pass [{ "month": 12, "amount": 1000 }] and the response includes interestSavings showing exactly how much a lump-sum prepayment saves over the loan term.

Need compound growth or savings goal projections? /api/v1/compound and /api/v1/savings cover those; /api/v1/roi computes return on investment and — with an optional years field — CAGR. All five calculators are pure JS, zero external dependencies.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/financial-calculator-api2

Do you compute financial projections client-side or delegate the math to an API?

EU VAT number validation in 3 lines of code: REST API backed by official VIES

Daniel Igel — Fri, 24 Jul 2026 13:00:02 +0000

EU SaaS checkouts often need to verify a customer's VAT number before applying B2B tax exemption. Hitting VIES directly means dealing with an inconsistent REST response — and doing that per-checkout adds latency you don't want.

GET /api/v1/validate?vat=DE811569869 forwards the number to the official VIES REST API (ec.europa.eu), validates it against all 27 EU member states plus Northern Ireland (XI), and returns clean JSON:

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

Response includes valid, countryCode, vatNumber, and — where the member state exposes it — the registered name and address. Results are cached for 1 hour so repeated lookups on the same number return instantly without hitting VIES again.

Validating a batch on invoice import? POST /api/v1/validate/batch takes up to 10 numbers at once:

const res = await fetch(
  'https://eu-vat-number-validator-api.p.rapidapi.com/api/v1/validate/batch',
  {
    method: 'POST',
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'eu-vat-number-validator-api.p.rapidapi.com',
      'content-type': 'application/json',
    },
    body: JSON.stringify({ vatNumbers: ['DE811569869', 'FR40303265045'] }),
  }
);
const { count, results } = await res.json();

Each item in results carries its own valid flag and an error field if VIES couldn't be reached for that number — one unreachable country doesn't block the rest of the batch.

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

Do you check VAT numbers at checkout time, or only when generating invoices?

Validate 100 IBANs at once: batch payment validation without a banking API

Daniel Igel — Thu, 23 Jul 2026 13:00:01 +0000

Importing a payment file with hundreds of IBANs and looping through a validation call per row adds latency and burns quota fast. Most teams either skip validation entirely or pull in a full banking SDK they don't need.

POST /api/v1/validate/batch sends up to 100 IBANs in a single request, runs MOD-97 checks against ISO 13616 specs for 85 countries, and returns a per-IBAN result plus aggregate counts:

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","INVALID123"]}'

Response includes validCount, invalidCount, and a results array — each entry carries the original IBAN so you can map back to source rows without index juggling. Need the bank code and account number too? GET /api/v1/parse?iban=... returns bankCode, accountNumber, and the display-formatted formattedIBAN (DE89 3704 0044 0532 0130 00) for a single IBAN.

const res = await fetch(
  'https://iban-validator-parser-api.p.rapidapi.com/api/v1/validate/batch',
  {
    method: 'POST',
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'iban-validator-parser-api.p.rapidapi.com',
      'content-type': 'application/json',
    },
    body: JSON.stringify({ ibans }),
  }
);
const { results, validCount, invalidCount } = await res.json();

No npm install, no external dependencies — built on Node.js built-ins.

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

Do you validate IBANs before storing them, or only at payment time?

Check domain availability, WHOIS and suggestions via REST API

Daniel Igel — Wed, 22 Jul 2026 13:00:02 +0000

Checking domain availability from app code usually means parsing inconsistent WHOIS text, guessing from DNS NXDOMAIN, or bundling a library you don't want. None of those give you structured data and alternatives in one step.

This covers availability, suggestions, and WHOIS with plain REST:

curl --request GET \
  --url 'https://domain-availability-checker-api1.p.rapidapi.com/api/v1/check?domain=myapp.io' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: domain-availability-checker-api1.p.rapidapi.com'

Returns { domain, available, method, estimatedPrice }. The check queries DNS A and MX records — no records means available.

For a domain picker, GET /api/v1/suggest?keyword=myapp checks 8 TLDs at once (.com, .io, .dev, .app, .co, .net, .org, .me) and returns availability + estimated price for each:

const { suggestions } = await fetch(
  'https://domain-availability-checker-api1.p.rapidapi.com/api/v1/suggest?keyword=myapp',
  { headers: { 'x-rapidapi-key': process.env.RAPIDAPI_KEY, 'x-rapidapi-host': 'domain-availability-checker-api1.p.rapidapi.com' } }
).then(r => r.json());

const available = suggestions.filter(s => s.available);

POST /api/v1/check/bulk checks up to 10 specific domains in one round-trip. For registrar info, expiry dates, and nameservers, GET /api/v1/whois?domain=example.com returns parsed WHOIS JSON — no regex over raw text.

DNS results are cached for 5 minutes. Built on Node.js dns/promises, no external quota.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/domain-availability-checker-api1

Do you add a domain picker to your SaaS onboarding, or let users type the full domain name themselves?

DNS lookup via REST API â€” resolve A, AAAA, MX, TXT, NS and CNAME records in your app

Daniel Igel — Tue, 21 Jul 2026 13:00:01 +0000

DNS queries in app code start simple and get awkward fast. You need A records for routing, TXT for ownership verification, MX for mail checks — each with different functions, different error shapes, and its own parsing logic.

One GET normalizes all of it:

curl --request GET \
  --url 'https://dns-lookup-api3.p.rapidapi.com/api/v1/lookup?domain=github.com&type=A' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: dns-lookup-api3.p.rapidapi.com'

type accepts A, AAAA, MX, TXT, NS, CNAME, SOA, or PTR. Pass type=ALL for a combined A/AAAA/MX/TXT/NS/CNAME/SOA response in one round-trip. Every result has the same shape: domain, type, records, ttl. Results are cached for 5 minutes.

const res = await fetch(
  'https://dns-lookup-api3.p.rapidapi.com/api/v1/lookup?domain=example.com&type=TXT',
  { headers: { 'x-rapidapi-key': process.env.RAPIDAPI_KEY, 'x-rapidapi-host': 'dns-lookup-api3.p.rapidapi.com' } }
);
const { records } = await res.json(); // SPF, DKIM, DMARC, ownership tokens

Need to check multiple domains at once? POST /api/v1/lookup/batch accepts up to 20 domain/type pairs in one round-trip — useful for CI pipelines or onboarding flows that verify domain ownership before provisioning. Reverse DNS is GET /api/v1/reverse?ip=8.8.8.8.

Built on Node.js dns/promises — no external service, no third-party quota.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/dns-lookup-api3

Which DNS record types do you query most from app code — A for routing, MX for mail checks, or TXT for verification tokens?

Live exchange rates from the ECB via REST API â€” no key, no sign-up required

Daniel Igel — Mon, 20 Jul 2026 18:59:54 +0000

Building a multi-currency feature usually means wiring up a third-party data service, signing up for another API key, and hoping their quota tiers fit your usage. The ECB (European Central Bank) publishes official reference rates daily — but parsing their XML, rebasing to non-EUR currencies, and adding a history lookup is more boilerplate than most apps need.

One GET returns live exchange rates for any base currency:

curl --request GET \
  --url 'https://currency-exchange-rate-api11.p.rapidapi.com/api/v1/rates?base=USD' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: currency-exchange-rate-api11.p.rapidapi.com'

You get base, date, and a flat rates object with every currency the ECB publishes, already rebased to your chosen currency. Need a direct conversion? Hit /api/v1/convert?from=USD&to=EUR&amount=250 and you get result and rate in one call. Dashboard spark-line? /api/v1/history?currency=USD&days=30 returns up to 90 days of daily rates.

const res = await fetch(
  'https://currency-exchange-rate-api11.p.rapidapi.com/api/v1/convert?from=USD&to=EUR&amount=250',
  { headers: { 'x-rapidapi-key': process.env.RAPIDAPI_KEY, 'x-rapidapi-host': 'currency-exchange-rate-api11.p.rapidapi.com' } }
);
const { result, rate } = await res.json();

Rates are cached for one hour and sourced directly from the ECB — no upstream API key, no hidden quota from a third-party data provider. Suitable for e-commerce price display, expense tracking, and invoice automation; not intended for live trading.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/currency-exchange-rate-api11

What's the trickiest part of multi-currency work you've had to handle — rounding edge cases, timezone cutoffs on rate updates, or something else?

IP Geolocation in your app without a local database: free REST API with MaxMind GeoLite2

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

IP geolocation usually means picking a provider, signing up, and either shipping a 60 MB binary inside your app or adding another third-party dependency. For most use cases that's more than you need.

One GET returns country, region, city, timezone, ISP, and ASN for any IPv4 or IPv6 address:

curl --request GET \
  --url 'https://ip-geolocation-api20.p.rapidapi.com/api/v1/geo?ip=8.8.8.8' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: ip-geolocation-api20.p.rapidapi.com'

You get country, countryCode, region, city, latitude, longitude, timezone, isp, and as. Primary lookups run against a locally hosted MaxMind GeoLite2 database — no external roundtrip. ip-api.com steps in as automatic fallback when the local DB is unavailable.

Need to geolocate the calling client without reading the IP on the frontend? GET /api/v1/geo/me reads X-Forwarded-For and X-Real-IP headers set by the proxy and returns the same payload — handy for server-side middleware or edge functions.

For enriching a list at once, the batch endpoint resolves up to 50 IPs in a single request with concurrent processing:

const res = await fetch(
  'https://ip-geolocation-api20.p.rapidapi.com/api/v1/geo/batch',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-rapidapi-key': process.env.RAPIDAPI_KEY,
      'x-rapidapi-host': 'ip-geolocation-api20.p.rapidapi.com',
    },
    body: JSON.stringify({ ips: ['8.8.8.8', '1.1.1.1'] }),
  }
);
const { count, results } = await res.json();

No local database to maintain, no separate GeoIP provider account.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/ip-geolocation-api20

What do you use today for IP geolocation in production — self-hosted MaxMind, a third-party API, or something else?

Turn any RSS or Atom feed into clean JSON with a single HTTP request

Daniel Igel — Sun, 12 Jul 2026 13:00:01 +0000

RSS feeds are everywhere, but they're XML — and most edge runtimes don't ship an XML parser. Writing one means bundling a dependency you'd rather not carry.

One GET returns any RSS 2.0, Atom, or JSON feed as normalized JSON:

curl --request GET \
  --url 'https://rss-to-json-api2.p.rapidapi.com/api/v1/parse?url=https://hnrss.org/frontpage&limit=10' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: rss-to-json-api2.p.rapidapi.com'

Every item comes back with the same shape — title, link, summary, published, author, categories, and guid — regardless of whether the source was RSS 2.0 or Atom. Results are cached for 5 minutes, so repeated polls don't hammer the upstream feed.

const res = await fetch(
  `https://rss-to-json-api2.p.rapidapi.com/api/v1/parse?url=${encodeURIComponent(feedUrl)}&limit=20`,
  { headers: { 'x-rapidapi-key': process.env.RAPIDAPI_KEY, 'x-rapidapi-host': 'rss-to-json-api2.p.rapidapi.com' } }
);
const { feedType, title, items } = await res.json();

Building a news aggregator? POST /api/v1/parse with { "urls": ["...", "..."], "limit": 5 } parses up to 10 feeds concurrently — each entry carries its own status field so partial failures don't silently break the batch.

Don't have the feed URL? GET /api/v1/discover?url=https://example.com crawls the page's <link> tags and common feed paths, returning every linked RSS, Atom, and JSON Feed URL with its type and title.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/rss-to-json-api2

What do you currently use to consume RSS feeds in production — roll your own XML parser, use a library, or delegate it to a service?

URL to screenshot in one GET â€” desktop, mobile, or custom viewport

Daniel Igel — Sat, 11 Jul 2026 13:00:01 +0000

Taking screenshots of web pages in automation usually means installing Chromium, managing a Playwright process pool, and keeping browser sessions from leaking memory in production. The setup works but is heavy — and it fails in odd ways when headless Chrome decides to hang.

One GET returns a base64-encoded screenshot, no Chromium setup required:

curl --request GET \
  --url 'https://website-screenshot-api8.p.rapidapi.com/api/v1/screenshot?url=https%3A%2F%2Fexample.com&viewport=mobile&format=webp' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: website-screenshot-api8.p.rapidapi.com'

Response includes success, format, width, height, image (base64 string), and size. Flip &fullPage=true to capture content below the fold, &darkMode=true for dark-mode rendering, &blockAds=true to strip ad frames. Set &responseType=binary to stream raw bytes directly.

Use POST when you need a custom viewport or want to wait for a selector before the capture fires:

const res = await fetch('https://website-screenshot-api8.p.rapidapi.com/api/v1/screenshot', {
  method: 'POST',
  headers: {
    'x-rapidapi-key': process.env.RAPIDAPI_KEY,
    'x-rapidapi-host': 'website-screenshot-api8.p.rapidapi.com',
    'content-type': 'application/json',
  },
  body: JSON.stringify({
    url: 'https://example.com',
    viewport: { width: 1280, height: 800 },
    format: 'png',
    fullPage: true,
    waitForSelector: '#main-content',
  }),
});
const { image, width, height } = await res.json();

waitForSelector delays the capture until a CSS selector appears in the DOM — useful for React or Vue pages that render content after the initial load. Viewport accepts either a preset string (desktop, mobile, tablet) or a custom { width, height } object.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/website-screenshot-api8

What do you use automated screenshots for — visual regression testing, OG image generation, or something else?

5 text analysis tasks in one POST â€” no LLM key needed

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

Setting up NLP in 2026 still means choosing between expensive ML platforms, fragile Python environments, or stitching together multiple services — each requiring its own LLM key.

One POST returns sentiment, a summary, named entities, keyword extraction, or zero-shot classification — all powered by Gemini, no LLM key of your own needed:

curl --request POST \
  --url 'https://ai-text-analysis-api.p.rapidapi.com/api/v1/sentiment' \
  --header 'x-rapidapi-key: YOUR_RAPIDAPI_KEY' \
  --header 'x-rapidapi-host: ai-text-analysis-api.p.rapidapi.com' \
  --header 'content-type: application/json' \
  --data '{"text": "The new product update is absolutely fantastic!"}'

Response:

{ "sentiment": "positive", "score": 0.95, "explanation": "Strong positive language." }

Five dedicated endpoints: /sentiment, /summarize, /entities, /classify, /keywords. Need a 3-sentence summary? Send {"text": "...", "sentences": 3} and get back summary, sentences[], and wordCount. Zero-shot classification takes any categories array — no model training or fine-tuning required.

const res = await fetch('https://ai-text-analysis-api.p.rapidapi.com/api/v1/entities', {
  method: 'POST',
  headers: {
    'x-rapidapi-key': process.env.RAPIDAPI_KEY,
    'x-rapidapi-host': 'ai-text-analysis-api.p.rapidapi.com',
    'content-type': 'application/json',
  },
  body: JSON.stringify({ text: 'Tim Cook announced the iPhone in Cupertino in 2007.' }),
});
const { entities, count } = await res.json();
// entities: [{ text: 'Tim Cook', type: 'PERSON' }, { text: 'Cupertino', type: 'LOCATION' }, ...]

Accepts up to 16,000 characters per request. Works from any HTTP client — Node, Deno, Cloudflare Workers, plain browser fetch. No SDK, no Python environment to set up.

Free tier on RapidAPI: https://rapidapi.com/danieligel/api/ai-text-analysis-api

Which text analysis task do you reach for most often in a backend project — sentiment, entity extraction, or something else?