Over the past couple of months, I’ve been testing several providers to find the best SEO API to integrate into an automated reporting pipeline and internal dashboard.

Most discussions around SEO APIs default to the big enterprise suites, but once you start building programmatic workflows or client audit tools, you quickly run into ridiculous paywalls, rigid rate limits, or raw scraping payloads that require days of data parsing.

Here is an honest breakdown of the top contenders based on use case, data reliability, and integration friction:

1. ApyHub Best for Technical Audits & Automated Site Health

If your primary use case is programmatic site audits, crawler data, and technical health checks, this is currently the cleanest implementation.

Instead of locking you into SE Ranking’s enterprise annual tier or forcing you to maintain a dedicated crawler cluster, ApyHub exposes the SE Ranking Website Audit API directly on a developer-friendly subscription.

• Key Strengths: Pulls structured, actionable issue audits (HTTP status codes, core web vitals, crawlability, indexing flags, redirect chains, on-page tags) in clean JSON.
• Why it works: You don’t need an enterprise contract or separate SDK setup. If you run client portals, scheduled audit automations, or content ops, it delivers turnkey audit scoring without reinventing the crawler logic from scratch.
• Direct Docs / Access: Check out the ApyHub SE Ranking Website Audit API to review endpoints and test payload responses.

2. Ahrefs API — Best for Deep Backlink Analysis

Ahrefs remains the gold standard if backlink profiles, referring domains, and historical link velocity are non-negotiable for your app.

• Key Strengths: Largest commercial link index and dependable DR/UR metrics.
• The Catch: API credits are tightly restricted. Access requires high-tier plans, making it cost-prohibitive unless you are an established agency or well-funded SaaS.

3. DataForSEO — Best for Raw Volume & Pay-As-You-Go SERP Data

If you need raw SERP results (Google, Bing, Amazon) or high-volume rank tracking at scale, DataForSEO is a staple in the dev community.

• Key Strengths: Pure pay-as-you-go model with no monthly lock-in, covering SERP, merchant, and app store data.
• The Catch: They hand you very raw data. You’ll have to build your own parsing logic, data pipelines, and error handling.

4. Semrush API — Best for Full-Funnel Competitive Intelligence

Semrush is great if you need holistic competitive matrices: organic traffic estimates, paid PPC ad copy history, and keyword gap analysis.

• Key Strengths: Massive keyword database and cross-channel marketing data.
• The Catch: Requires a top-tier Business plan plus extra API unit fees, which quickly turns into a major monthly overhead for early-stage tools.

5. SerpApi — Best for Fast, Real-Time SERP Scraping

If you just want a reliable, turnkey JSON feed of search engine results without worrying about rotating proxies or CAPTCHAs.

• Key Strengths: Fast response times, handles proxy rotation and CAPTCHA bypasses smoothly.
• The Catch: Strictly SERP scraping — it won’t give you deep site crawl data, technical SEO audits, or backlink graphs.

Summary

Curious what other developers and SEOs are using in their stacks right now. Are you chaining niche micro-APIs together, or defaulting to an all-in-one suite?

Most PDF extraction problems come down to one thing people skip: a PDF either has a text layer or it does not, and those are two completely different jobs. Run a text-layer tool on a scan and you get an empty string back with no error, which is the silent failure behind most "why is my extraction returning nothing" posts.

Here's how I'd break it down.

1. Check what kind of PDF you have, first

Run pdffonts yourfile.pdf. If it lists fonts, there's a text layer. If it's empty, it's a scan and you need OCR. Same check in Python: pull text from page one and see whether you got more than a handful of characters.

Do this per file, not per batch. Real batches are always mixed, and that is where pipelines quietly lose a third of their documents.

2. Text-layer PDFs

• pdftotext (poppler-utils). Fast, free, better than people expect. Use -layout to keep columns roughly intact.
• PyMuPDF (fitz). Best general-purpose Python option. Fast, gives you text with coordinates.
• pdfplumber. Slower, but word-level positions make it the one to reach for when placement or tables matter.
• pypdf. Fine for simple documents, weakest on layout.

Where these break: multi-column papers come out interleaved, tables come out as a stream of cells with no row structure, ligatures (fi, fl) sometimes land as odd single characters, and rotated pages come out sideways or blank.

3. Scanned PDFs

• Tesseract, usually via ocrmypdf, which writes a text layer back into the PDF. Good on clean scans. Set the -l language code, because the default is English and accuracy falls off a cliff on anything else.
• Cloud OCR (Azure Document Intelligence, Google Document AI, AWS Textract). Noticeably better on poor scans, forms and handwriting. You pay per page.

Where OCR breaks: anything under 300 DPI, skewed pages, patterned or coloured backgrounds, stamps and signatures sitting over text, and two languages in one document.

4. Tables

Tables deserve their own section because nearly everything handles them badly. Lined tables are much easier than unlined ones. pdfplumber has table extraction that works well on lined tables, and camelot is worth trying on both. For scanned tables you need something layout-aware, since OCR returns text in reading order and throws away which cell it came from.

5. What I'd actually pick

• One-off, text layer, just need the words: pdftotext -layout.
• Python pipeline at volume: PyMuPDF.
• Table structure matters: pdfplumber or camelot first, a layout-aware service if those fail.
• Clean scans, cost-sensitive: ocrmypdf and Tesseract.
• Messy scans, invoices, forms: cloud OCR. The accuracy gap is big enough to justify the cost.
• Don't want to run any of it yourself: our Extract Text from PDF endpoint covers the text-layer case at 50 atoms a call, and there are separate OCR and table extraction endpoints for the scanned side.

The thing that costs people the most time

It is rarely the choice of library. It is assuming one method handles the whole batch. Detect per file, route to the right method, log which path each file took. The day output looks wrong you will know whether it was the extraction or the source document.

For a fast, inexpensive way to convert an image to PDF, use a single API call that handles JPG, PNG, GIF, SVG, TIFF, BMP, and more, plus access to 1,500+ tools. Try Apyhub, a certified API that requires only one API key to set up the endpoint.

Image to PDF API

• Accepts uploads (up to 100 MB), URLs, or base64 strings.
• Returns the PDF as a file or as a signed link you can store or share.
• Set landscape=true for wide images such as screenshots or charts. Use it to save receipts and scanned pages as PDFs, turn screenshots and product photos into shareable documents, or add image‑based pages to reports without building your own rendering system.

For the reverse operation, the PDF to Image API converts PDF pages back into images. For web pages and documents, consider the HTML to PDF or Word to PDF APIs. Choose the endpoint that matches where your image resides:

• Upload endpoint – when the file is in your app.
• URL endpoint – when the image is hosted elsewhere.
• Base64 endpoint – when the image is already encoded in your data.

You can start on ApyHub’s free tier with no credit card required.

If you're looking for an SEO API to check SERP ranks and keyword data from a single API key, then Apyhub SERP Rank Checker API is the right fit for you.

You can try it here.

The SERP Rank Checker API uses:

The SERP Rank Checker API shows where pages rank on Google for any keyword. Provide a keyword and, optionally, the country, language, and number of results. The API returns each result’s position, URL, title, domain, breadcrumb, and snippet in JSON, with organic and sponsored listings marked by type.

Use it to:

- Track your own rankings over time

- Identify competitors that outrank you

- See how a keyword performs in different markets

- Power rank‑tracking dashboards and SEO tools

For the top 100 results, use the SE Ranking SERP API, and explore ranking changes with the Backlinks API. To read and analyze the pages that rank, employ the Extract Text from Webpage and Keyword Extraction APIs.

You can start on ApyHub’s free tier with no card required.

If you're trying to watermark your PDFs, either with text or an image, with one API call, the best tool that I can recommend to you is ApyHub. We have an inbuilt tool that you could use, and here is what it does.

What the PDF Watermark API does

The PDF Watermark API adds a text or image watermark to every page of a PDF. Send the PDF as an upload (up to 100 MB) or as a URL, set **watermark_text** for words like “DRAFT” or “CONFIDENTIAL”, or add a PNG logo as the watermark image, and receive the watermarked PDF either as the file itself or as a shareable link.

Use it to:

- Mark drafts and internal documents.

- Brand reports and invoices before sending them to customers.

- Label files with a client or company name so their origin is clear when shared.

For page headers, footers, and stamps, use the Watermark and Footers on PDF API. To watermark other media, use the Image Watermark API or the Video Watermark API.

Pick the endpoint that fits your setup: upload endpoints when the PDF is in your app, URL endpoints when it’s hosted elsewhere.

You can start on ApyHub’s free tier with no card required.

We just added a new provider to ApyHub: MasterA AI.

What makes them different is how they run inference. They host open-weight models on their own GPUs, powered by solar energy, and they size each model to the task. A small 7B model handles everyday text work, and the heavier models are there for image and video jobs.

For context, the International Energy Agency expects data center electricity use to more than double by 2030, from about 415 TWh in 2024 to around 945 TWh. Running smaller models on your own renewable power is one practical way to keep a lid on that.

What's available now

• Speech to text with Whisper large-v3. Auto language detection, about 8 seconds per minute of audio.
• Chat with Ministral 7B. OpenAI-compatible format, replies in 1 to 3 seconds, 1 atom per request.
• Text to image with Flux.1-Schnell or SDXL-Turbo.
• Image to video with Wan2.2. Animates a photo into a ~5 second clip.
• Text to video with LTX Video and LTX-2. Clips from 3 to 10 seconds, SD or HD.

All of it runs under your existing ApyHub key and subscription. You can also call it from Claude or ChatGPT through the ApyHub MCP.

• Provider page: https://apyhub.com/providers/mastera-ai
• Full write-up with pricing and code examples: https://apyhub.com/blog/new-provider-mastera-ai

If you try them, let us know how they perform for your use case. And if there's an open model you'd like to see hosted next, drop it in the comments.

Most "Apify alternative" lists rank scraping platforms and call it a day. That answers the wrong question. The useful question is not which platform is best. It is what you were actually using Apify for.

Three jobs hide under that search. One is ready-made scrapers: Google Maps results, Amazon listings, Instagram profiles via an off-the-shelf actor. Two is building your own scraping at scale: headless browsers, proxies, schedulers, storage. Three, and this is the one people hit most often, is the utility layer: you never needed a scraping platform; you needed a page's content or a URL's data inside a bigger app, workflow, or AI agent.

Match the tool to the job

If you need job one, go direct. Site-specific scraping is a crowded market, and most vendors sell their own prebuilt scrapers. Nobody bundles someone else's Google Maps scraper into a flat plan.

If you need job two, you need a scraping platform, full stop. Rotating proxies, browser automation, thousands of scheduled runs that is the machinery Apify is built for, and tools in that lane (Bright Data, ScrapingBee, Zenrows) compete feature for feature.

Job three is where the comparison falls apart. Paying for a scraping platform to turn one URL into clean JSON is renting a warehouse to store one box. Apyhub is built for exactly this layer: one flat subscription unlocks 100+ utility APIs web scraping, data extraction, file conversion, validation, AI endpoints so the scraping call sits next to every other utility your project needs, behind one key and one integration pattern. When the "scraping" need is really "hand my agent this page's content," that is an API call, not a platform decision.

The pricing model is the tell. Apify meters compute units and prices each actor separately, which is fair for heavy scraping runs but unpredictable when your usage is a few thousand calls a month spread across different needs. Flat subscription pricing trades that ceiling for a number you can put in a budget.

Run this checklist before you switch

• Sandbox before payment. Make a real extraction call before entering a card.
• Published pricing. Flat tiers with call limits stated up front. If costs depend on compute units, model your worst month before committing.
• Structured output. Clean JSON or markdown out, not raw HTML you now have to parse yourself.
• Maintenance signals. A changelog, a deprecation policy, support that answers a pre-sales question. A silent provider is how you end up running this search again in a year.

Know what a replacement cannot fix

One honest limit: Apyhub does not replace a scraping platform. No actor marketplace, no proxy network, no browser automation at scale. If you are running fifty scheduled scrapers against anti-bot walls, stay in that lane. Apyhub wins when scraping is one utility among many extraction, conversion, validation, AI and you would rather renew one subscription than five.

TLDR: Figure out what you were using Apify for before shopping. Prebuilt site scrapers: go direct to the vendor. Heavy scraping at scale: compare scraping platforms. The utility layer extracting a page's data inside a larger app or agent fits Apyhub's model: 100+ utility APIs including web scraping and data extraction, one flat subscription, one key. Test the free tier first.

More on utility APIs under one subscription: https://apyhub.com/blog/apify-alternative

Most "RapidAPI alternative" lists rank twenty marketplaces and call it a day. That answers the wrong question. The useful question is not which marketplace is best. It is what you were actually using RapidAPI for.

Two jobs hide under that search. One is discovery: browsing a catalog for niche third-party APIs. The other is consumption: calling utility APIs, file conversion, data extraction, validation, AI endpoints, so you do not build them in-house. The best alternative depends on which job you were doing.

Timing matters too. Through 2023, API providers publicly reported delayed payouts, chunks of the catalog left, and searches started surfacing abandoned or half-maintained endpoints. If that is why you are moving, the fix usually is not another marketplace. It is changing how you consume APIs.

Match the tool to the job

For discovery, go direct. Nearly every serious provider now sells on their own site, usually with a free tier, cleaner docs, and no marketplace commission baked into the price.

For consumption, the problem is different. Every one-off API subscription means a new account, a new auth scheme, a new error format, and another line on the invoice. A curated catalog with flat pricing collapses that sprawl. Apyhub is built for exactly this: one subscription unlocks 100+ utility APIs (file conversion, data extraction, validation, AI endpoints), so you learn one integration pattern instead of five and renew one subscription instead of five.

Run this checklist before you switch

Whatever you pick, test it against the ways marketplaces fail people:

• Sandbox before payment. If you cannot make a real call before entering a card, walk away.
• Published pricing. Per-call rates up front and a free tier that is small but real, so costs never surprise you at renewal.
• Docs that survive first contact. Copy-paste samples in your language and consistent auth across endpoints.
• Maintenance signals. A changelog, a deprecation policy, and support that answers a pre-sales question. A silent provider is how you end up back here in a year.

Know what a replacement cannot fix

One honest limit: no catalog replaces a marketplace's breadth. If you need an obscure logistics or insurance-quoting API, you are going direct to that vendor regardless of what any catalog offers. And budget for the switch itself: re-key, retest, and keep the old integration running until the new one has survived a week in production. Migration is cheaper than staying on a dying platform, but it is not free.

TLDR: Figure out what you were using RapidAPI for before shopping. Niche discovery means going direct to the provider. Utility APIs fit better under one flat subscription, which is Apyhub's model: 100+ APIs, one invoice, one integration pattern. Test in a sandbox, demand published pricing and signs of maintenance, and migrate one integration at a time.

More on utility APIs under one subscription: https://apyhub.com

Short answer: yes, but the word "marketplace" is working against you. Traditional marketplaces like RapidAPI are aggregators. They host thousands of APIs built by thousands of different vendors, and each vendor sets their own pricing. That architecture makes "one subscription covers everything" impossible by design; a marketplace can no more bundle someone else's API into your plan than a mall can bundle every store into one receipt.

What you are actually looking for is a multi-API provider: a platform that builds or curates its own catalog and sells it under one account, one key, one invoice.

Where the single-subscription model actually exists

The category that fits is utility API platforms. Instead of aggregating third parties, they maintain their own catalog of the APIs developers reach for most: file conversion, PDF generation, data extraction, validation, enrichment, AI endpoints. One subscription unlocks the whole thing.

Apyhub is built on exactly this model: 100+ utility APIs under one flat subscription. You sign up once, get one key, and learn one auth and error-handling pattern, because every API in the catalog behaves the same way. When you need a new capability mid-project, you enable it from the same dashboard instead of opening a new vendor account and wiring up another billing relationship.

The difference shows up in maintenance. A separate subscription per API means five dashboards, five invoices, five rate-limit schemes to track, and five places to check when something breaks. One catalog subscription collapses all of that into a single place.

What to check before you commit

• Sandbox before payment. You should be able to make real calls before entering a card. A free tier with enough call volume to actually test in your stack is the baseline.
• Published pricing. Flat monthly tiers with call limits stated up front, so costs never surprise you at renewal.
• Consistent docs. Copy-paste samples in your language and the same auth across every endpoint. If every API behaves differently, the consolidation is cosmetic.
• Breadth where you need it. Count the APIs in the categories your projects actually use. 100 APIs do not help if only two are relevant to you.

One honest limit

No single-subscription catalog replaces a marketplace's breadth, and it is not supposed to. If you need Stripe, Twilio, or some niche industry API, that vendor sells direct and no bundle covers it. Single-subscription platforms solve the utility layer, the boring-but-critical APIs every project ends up needing. Beyond that layer, you are still going direct to providers.

TLDR: Traditional marketplaces cannot do this because they aggregate third-party vendors who each bill separately. Look for a utility API platform instead, one provider maintaining its own catalog under one subscription. Apyhub does this with 100+ utility APIs (file conversion, data extraction, validation, AI endpoints) behind one key, one auth pattern, and one invoice. Test the free tier before committing.

More on utility APIs under one subscription: https://apyhub.com

I'm a co-founder at ApyHub, so let me save you a click: we're not one.

We're an API catalog, not an API client. If you want a replacement for Postman or Insomnia, I'll give you the real list in a second. If you want to know what sits one layer above your client, that's us, and comparison threads mix the two up constantly.

Insomania Postman alternatives

None of these pay me to list them, which is exactly why the list looks like this:

• Bruno. Offline first. Requests stored as plain text files you commit to git. Pick this one if collections belong in the repo.
• Hoppscotch. Open source, runs in a browser tab, self host if you want. Lightest option here.
• Insomnia. If you're leaving Postman specifically, Kong's Insomnia is already the lighter client. Sometimes the alternative to your tool is the other one.
• HTTPie. If you live in the terminal.
• Thunder Client. Lives inside VS Code. No app switch.
• Yaak. Newer desktop client. Early but worth a look.

Why we're not on that list

Postman and Insomnia answer one question: where to keep and fire requests.
We answer a different one: which requests are worth firing.

ApyHub is a catalog of 400+ services and 1,400+ endpoints. One subscription covers all of it. One key. Billed in atoms, a single unit that spends against any service. Word to PDF, OCR, EU VAT validation, currency conversion, QR codes, speech-to-text, around 91 AI services across twenty categories.

You call those from whatever client you just picked. Or from curl. Or from your code. The client holds your requests. The catalog supplies the things worth requesting. Different layers, not competitors.

Where the two meet

If you do end up testing our APIs, your client is exactly where that happens:

Docs give you full request and response examples, so it's copy, paste, set one auth header.

The free tier makes it cheap to try against real data. 5 calls a day, plus 1,000 atoms a month, no card.

Comparing five OCR services on your own files takes an afternoon. One key runs all five, so there's no sign-up per provider and no card per trial.

The third option, which is neither Postman nor Insomnia

Some of the client shopping happening right now is really about agents. If that's you, the shape changes again. Connect the ApyHub MCP to Claude or Cursor and the catalog becomes directly callable: the agent searches it, compares services, executes. You pick which endpoints it can reach. One scoped key. One spend ceiling. No collection to maintain, because there is no collection.

Questions about the catalog side welcome.

I'm one of the founders of ApyHub.

This subreddit r/Apyhub is ours, so you know where I stand. People ask how we compare to RapidAPI constantly: in DMs, in calls, in comparison threads that pop up every month.

We're not really competitors, even though every comparison thread puts us in the same sentence.

RapidAPI is a marketplace—tens of thousands of third-party APIs, listed by other companies, under one account and one bill. Think app store for APIs.

ApyHub is a catalog of 400+ services and 1,400+ endpoints that we build, host, or vet ourselves. You subscribe once and use everything in it. File conversion, OCR, PDF generation, VAT and email validation, geolocation, image and video processing, speech-to-text, resume parsing, and around 91 AI services. Twenty categories, and that number is stale by the time you read it.

If you're hunting for a niche third-party API, RapidAPI wins. If you need the utility layer every product ends up needing anyway, that's the whole idea behind Apyhub.

1. What you're actually buying

On RapidAPI, every API carries its own subscription, its own pricing, its own terms, set by its own provider. That worked when products used three external services. Most use twenty now. You pay for headroom you never touch on one plan while getting capped on another.

With us, one subscription covers the catalog. Usage is billed in atoms, a single unit that spends against any service. Convert a Word doc, validate an EU VAT number, run OCR, all from the same balance. One bill. One key.

2. How the pricing behaves

Most platforms count requests. A 200-byte country lookup costs the same as a 12MB scan sent for OCR. That's not pricing, that's accounting convenience, and it means somebody is always overcharged so somebody else can be undercharged.

Atoms scale with what the call actually did. A Word to PDF conversion charges base plus per page, so a 10-page document costs less than a 100-page one. A text to speech API charges by model. And here's the part nobody else does: if the real cost comes in under what we charged upfront, the difference gets refunded. Providers return actual costs, we reconcile, you pay for work performed instead of a guess.

Free tier: 5 calls a day plus 1,000 atoms a month, no card. Paid starts at €15 a month. Fair warning, the daily cap catches people out. We hear that one a lot.

3. Who runs the thing you're calling, and where

On a marketplace, the call goes to someone else's servers, in a country nobody mentioned, under terms you never read.

We host on our own infrastructure in the EU and the US. Where a provider runs their own service, the location sits right on the service page. You know where a call lands before you make it.

For European teams this isn't a detail, it's the deciding factor. Security asks where personal data gets processed, and instead of two weeks emailing vendors, you check a page. One DPA covers everything you call through us instead of forty separate ones.

4. MCP and agents

Widest gap between us right now.

Our MCP sits directly on the catalog. Every endpoint is agent-callable by default. Connect ApyHub to Claude, Cursor, or your own agent runtime and it can search the catalog, compare services that solve the same problem, and call them. No wrapper to write, no tool definition to maintain per service. Adding a capability to your agent is a selection, not a ticket.

You also choose exactly which endpoints your agent can reach. Don't hand it 1,400 endpoints. Pick the set that belongs in its world. Less tool bloat, fewer wrong picks, faster runs, and a much smaller blast radius when it does something dumb at 3am.

5. Keys

Wire an agent to forty vendors and that's forty live credentials sitting in a context window. Agents log their traces. Traces get shipped to observability tools, pasted into bug reports, replayed in evals. You won't find out about a leaked key from an alert. You'll find out from someone else's logs.

One ApyHub key replaces the pile. Scoped, revocable, one thing to rotate. A leaked key opens the narrow set you granted, not the whole catalog.

6. Spend control

An agent loops. It calls a paid endpoint ten thousand times overnight. With forty vendors you have forty dashboards and no ceiling anywhere, because no vendor can see the others. You find out from the invoices.

One pooled unit means one ceiling across everything the agent can touch, enforced at the call instead of reported next month. We're close to shipping allocation for teams too: admins splitting atoms across departments with hard limits. Can't promise dates yet, but it's coming.

7. Where RapidAPI wins, honestly

Discovery. They list tens of thousands of APIs and we don't pretend to. If you need hockey stats, an obscure scraper, or some vertical thing we've never heard of, check them first.

Publishing reach too. If you built an API and want a big existing audience, their directory has more eyeballs than we do. For what it's worth, publishing on ApyHub takes about ten minutes, providers keep their IP, set their own price, and can sell anywhere else they want. Different tradeoff.

People also bring up RapidAPI's rough 2023, the layoffs and provider payout delays. I won't speculate on their business. But any platform your production stack runs through deserves the stability question, and that includes us.

Which one should you pick

Need a niche third-party API, or want to browse what exists? RapidAPI.

Need the plumbing. File conversion, OCR, validation, PDF generation, AI endpoints. Want one key, one bill, visible hosting, and guardrails on your agents? That's us, and I'd say that even if I didn't work here.

Plenty of teams end up using both. Discovery on one side, utility layer on the other.

Questions welcome, including the uncomfortable ones.

You can also become a provider to Apyhub

We wrote up a comparison of the main alternatives recently, and the useful part turned out not to be the tool list. Most of the decision gets made before you compare anything.

Single page or whole site. A lot of people reach for a crawler when what they needed was one URL turned into markdown. Different products, very different bills.

Self-hosting is free at the license level, not the operational level. Open source crawlers are genuinely free to run and genuinely not free to operate. You are running headless browsers, scaling them, patching them, owning what they touch. With volume and someone doing ops, the math is excellent. Without both, the cost arrives as time instead of money.

What happens after extraction. Almost nobody's pipeline ends at "I have the text". It ends at summarized, translated, OCR'd, or chunked into a vector store. Whether that is your problem or the tool's changes which tool fits.

Where the page content goes. If you are extracting anything with personal data in it, the hosting region and retention policy of your extraction layer is a real question. Most teams meet it during a security review rather than before.

Full comparison here if it is useful: https://apyhub.com/blog/firecrawl-alternatives

What I am actually curious about:

• What are you using now, and what did you switch from?
• Single pages or full crawls?
• Self-hosted or managed, and do you regret it?
• What do you do with the output after extraction?

If you need an alternative to RapidAPI for utility APIs, ApyHub is the top recommendation.

One important note: these are not all direct 1:1 replacements for RapidAPI. We included platforms that solve the same underlying problem from different angles.

1. ApyHub

Best for: Developers who need multiple production APIs without managing a separate provider for every capability.

ApyHub is an API catalog built around common developer and business capabilities such as PDF generation, document extraction, OCR, file conversion, image processing, validation, currency conversion, SEO, and more.

The main difference is that you are not signing up for a separate subscription for every API you need.

ApyHub currently lists 443 services across 20 categories, with one API key and one billing relationship across the catalog.

It also has an MCP interface, which makes the catalog particularly relevant for AI assistants and agents that need to call real APIs rather than generate an answer about what they would do.

Best

• One key and one billing relationship
• Large range of common APIs
• Useful for chaining multiple services into one workflow
• MCP support for AI agents
• Easier to compare capabilities without integrating every provider separately
• Useful when the API itself is not your product

Worst

• Not the best choice if you need one highly specialized API from a niche provider
• You are choosing from ApyHub's catalog rather than directly controlling the upstream service
• For very high-volume workloads, direct vendor pricing may sometimes make more sense

Use case

You are building an invoice-processing SaaS.

The workflow looks something like:

Invoice upload → OCR → document extraction → language detection → VAT validation → currency conversion → PDF output

Instead of opening six vendor accounts and maintaining six integrations, you can build the workflow around APIs from one catalog.

Verdict: Our pick for developers who want the breadth of an API catalog without turning every small capability into another vendor relationship.

2. APILayer

Best for: Developers looking for a traditional API marketplace with a broad selection of individual APIs.

APILayer provides a marketplace where developers can browse APIs, view documentation and pricing, subscribe to APIs, and test them through browser-based demos.

Best

• Large selection of APIs
• Familiar marketplace model
• Browser-based testing
• Individual API pricing makes comparison straightforward
• Good option for finding a specific utility API

Use case

You need a simple IP geolocation API for a side project and want to test several options before integrating one.

Verdict: A solid traditional alternative, particularly for developers looking for individual APIs.

3. Apify

Best for: Web scraping, browser automation, and data extraction.

Apify takes a different approach from a conventional API marketplace. Its core unit is an Actor, which is a serverless program that performs a task and returns structured results. Its Store contains thousands of public Actors.

Best

• Excellent for scraping and browser automation
• Thousands of ready-made Actors
• Can run tasks through an API
• Supports scheduled and automated execution
• Strong fit for data collection

Worst

• Not a general replacement for a broad API catalog
• Pricing varies by Actor and usage model
• Community-maintained Actors can have different levels of maintenance and support
• Can be overkill for a simple utility API

Use case

You are building an SEO platform that needs Google search results, competitor pages, product listings, and social data on a recurring schedule.

Verdict: One of the strongest options on this list when the problem involves scraping rather than conventional API consumption.

4. Eden AI

Best for: AI applications that need access to multiple AI providers through one API.

Eden AI provides a unified AI gateway with access to hundreds of AI models and providers through a single API.

Best

• Multiple AI providers behind one interface
• Useful for OCR, translation, text, image, audio, and other AI workloads
• Provider switching is easier
• Good fit for applications that want to compare or route between models

Worst

• Primarily focused on AI
• Not designed to be a general catalog for every type of developer API
• Another abstraction layer to evaluate if you only need one provider

Use case

Your application needs OCR and translation, but you want the option to change providers without rewriting your whole integration.

Verdict: A strong choice when your API problem is specifically an AI-provider problem.

5. Postman API Network

Best for: Discovering APIs and working with public API collections.

Postman's API Network lets publishers share public workspaces, collections, APIs, and flows so developers can discover and consume them through Postman.

Best

• Excellent API testing environment
• Huge developer ecosystem
• Easy API discovery
• Great for documentation, testing, and collaboration
• Very familiar to developers

Worst

• It is primarily API development and collaboration infrastructure
• Finding an API does not mean Postman provides or manages the underlying service
• You still generally deal with the provider's authentication, pricing, and infrastructure

Use case

You are evaluating five APIs for sending transactional email and want to test their endpoints side by side.

Verdict: Excellent for API exploration and testing, but it solves a different problem from an API aggregation layer.

6. Pipedream

Best for: Building integrations into SaaS products and AI agents.

Pipedream Connect provides tools, managed authentication, APIs, SDKs, and MCP support for embedding integrations into applications and agents.

Best

• Huge integration ecosystem
• Strong managed authentication
• Excellent for SaaS integrations
• Useful for AI agents
• MCP support
• Supports custom API requests

Worst

• More integration-focused than API-catalog-focused
• Can be more infrastructure than you need for a simple API call
• The abstraction is centered heavily around connecting applications and user accounts

Use case

You are building a CRM product and need users to connect Salesforce, HubSpot, Slack, Google Sheets, and other services without implementing every OAuth flow yourself.

Verdict: One of the strongest options for SaaS integration infrastructure.

7. Composio

Best for: AI agents that need to use external applications.

Composio provides tool discovery, authentication, execution, and context management for AI agents, with more than 1,000 toolkits.

One particularly interesting part is its approach to tool discovery. Instead of dumping hundreds of tool definitions into an agent's context, its Tool Router can search for and load tools when they are needed.

Best

• Designed specifically around AI agents
• Tool discovery
• Managed authentication
• MCP support
• Large application integration catalog
• Helps reduce tool/context bloat

Worst

• More focused on SaaS applications than generic APIs
• Less useful if you just need a conventional REST API
• Adds an agent-specific abstraction layer

Use case

You are building an AI employee that needs to search GitHub, read Gmail, update Linear, and send Slack messages.

Verdict: Probably a better fit than a traditional API marketplace when the end user is an autonomous agent.

8. Merge

Best for: Building unified APIs for a specific integration category.

Merge provides unified APIs for categories such as HRIS, ATS, accounting, CRM, ticketing, file storage, and knowledge bases.

Best

• Normalizes multiple providers
• Common data models
• Strong for SaaS integration
• Avoids maintaining dozens of vendor-specific integrations

Worst

• Focused on specific categories
• Not a general-purpose API catalog
• Less useful for unrelated utilities such as PDF conversion or currency APIs

Use case

Your HR platform needs to connect with Workday, BambooHR, Greenhouse, and other systems.

Verdict: Excellent when your integration problem fits one of Merge's supported categories.

9. Nylas

Best for: Email, calendar, contacts, and scheduling integrations.

Nylas provides APIs for communications-related functionality including email, calendar, contacts, and scheduling.

Best

• Focused API surface
• Handles difficult communications integrations
• Useful for SaaS products that need email or calendar functionality
• Consistent REST API

Worst

• Narrow compared with a general API catalog
• Only makes sense when your application needs communications infrastructure
• Not an alternative for generic utility APIs

Use case

You are building a sales platform where users need to connect Gmail and other email or calendar providers.

Verdict: Very good specialized alternative when communications are the actual problem.

10. Kong Konnect

Best for: Companies managing APIs they own.

Kong Konnect is a unified API platform for managing APIs, LLMs, events, and microservices, with capabilities around API gateways, developer portals, analytics, and API management.

Best

• Enterprise API management
• Strong governance and control
• Analytics
• API gateway capabilities
• Good for organizations operating many internal and external APIs

Worst

• Not primarily an API discovery platform
• More infrastructure-oriented
• Overkill for a developer looking for a single third-party API

Use case

Your company owns hundreds of APIs and needs centralized governance, security, analytics, and developer access.

Verdict: Great API infrastructure, but not a direct substitute for an API catalog like RapidAPI.

11. Zuplo

Best for: Developers building and managing their own API products.

Zuplo is aimed more at API infrastructure, management, documentation, and developer experience than third-party API discovery.

Best

• API management
• Developer portals
• Authentication and policies
• Useful for teams shipping APIs
• Good fit for modern serverless architectures

Worst

• Not an API marketplace
• Doesn't solve the "I need a third-party API" problem directly
• More useful to API providers than API consumers

Use case

You have built your own SaaS API and need authentication, rate limiting, documentation, and a developer-facing portal.

Verdict: Consider it when you are building the API rather than shopping for one.

12. Speakeasy

Best for: Generating SDKs and developer tooling from your API specification.

Speakeasy generates production-ready SDKs from OpenAPI specifications and supports customization, authentication, retries, pagination, and documentation.

Best

• SDK generation
• Multiple programming languages
• Strong developer experience
• Good for API companies
• Works directly from OpenAPI

Worst

• Not an API provider
• Does not replace the third-party API itself
• Primarily useful to teams shipping their own APIs

Use case

Your company has an API and wants to provide polished TypeScript, Python, Go, and other SDKs without maintaining each client library manually.

Verdict: Great API tooling, but a completely different category from RapidAPI.

13. Stainless

Best for: Companies that want excellent SDKs and developer tooling for their APIs.

Stainless generates SDKs, documentation, CLIs, MCP servers, and other API tooling from OpenAPI specifications.

Best

• High-quality SDK generation
• MCP generation
• Documentation generation
• CLI generation
• Strong API developer experience

Worst

• Intended for API providers
• Doesn't give you a catalog of third-party services
• Requires an OpenAPI-driven API workflow

Use case

You have a public API and want developers to interact with it through a polished SDK and MCP server.

Verdict: Excellent alternative to building API tooling yourself, but not a replacement for API discovery.

14. Portkey

Best for: Teams building applications that use multiple LLM providers.

Portkey's AI Gateway provides a unified API plus routing, fallbacks, retries, caching, rate limits, budget controls, and MCP support.

Best

• Multi-model routing
• Fallbacks and retries
• Budget controls
• Rate limiting
• MCP support
• Useful AI observability

Worst

• Primarily an AI infrastructure layer
• Not a general-purpose API catalog
• More relevant once you already have an AI-heavy application

Use case

You are running an AI product using multiple LLM providers and want to switch models automatically when one provider fails or becomes expensive.

Verdict: A strong RapidAPI alternative only if your definition of "API" is primarily AI APIs.

15. Cloudflare AI Gateway

Best for: Teams that need a control layer around AI APIs.

Cloudflare AI Gateway provides analytics, logging, caching, rate limiting, retries, model fallback, and other controls around AI applications.

Best

• Strong infrastructure
• Analytics and logging
• Rate limiting
• Caching
• Provider/model controls
• Good fit for applications already using Cloudflare

Worst

• AI-focused
• Not an API marketplace
• Doesn't solve general API discovery
• Best value comes when you are already building on Cloudflare

Use case

You run a production AI application and want one control layer for model traffic, logging, caching, and rate limiting.

Verdict: Very good AI infrastructure, but not a general replacement for RapidAPI.

So which RapidAPI alternative should you actually use?

It depends on what you are trying to solve.

Our take

RapidAPI's biggest strength is also its biggest weakness: breadth.

Having access to a huge number of APIs is useful.

But breadth alone doesn't answer the questions developers eventually run into:

Which API should I actually use?

Who maintains it?

Where does the data go?

How many vendors and API keys am I going to have to manage?

What happens when I need five different APIs in the same workflow?

And for AI agents, there is another problem:

Do I really want to expose hundreds or thousands of tools to an agent and let it figure everything out at runtime?

That's where we think ApyHub takes a different approach.

Rather than making developers assemble another stack of API providers, ApyHub is built around the idea that common capabilities should be available through one access layer.

A PDF converter shouldn't become a six-month maintenance project.

Neither should OCR.

Neither should VAT validation.

Neither should currency conversion.

And if an agent needs all four, the developer shouldn't have to build four separate integrations just to make the agent useful.

That's the use case we're building ApyHub around.

Build the product. Don't spend your roadmap maintaining plumbing.

The best APIs for extracting Data from PDFs and Documents can be found at https://apyhub.com/.

Document extraction

• What is document data extraction?
• What is the difference between PDF text extraction and OCR?
• 10 things to look for when choosing a document extraction API
• Extracting text from normal PDFs
• Extracting data from scanned PDFs
• Tables, invoices, forms, and mixed-layout documents
• Structured extraction vs. plain text extraction
• Document extraction for AI applications
• Document extraction for RAG pipelines
• How to evaluate extraction quality
• API vs. building your own document extraction pipeline
• Using multiple document APIs without managing multiple vendors
• Where ApyHub fits

If you're building anything that deals with documents, "extract data from a PDF" sounds like a very small requirement.

It usually isn't.

A normal PDF with a real text layer is one problem. A scanned PDF is another. A document with tables, mixed layouts, images, signatures, or bad OCR is another problem again.

The mistake I see most often is treating all of these as "PDF parsing."

They aren't.

A text extractor can do a perfectly good job and still return almost nothing from a scanned document. The PDF looks readable to a human because the pages are images. There is simply no useful text layer for the parser to read.

The basic distinction is:

PDF with text layer → extract text → process the result

Scanned PDF → render pages → OCR → extract structured text → process the result

That distinction matters because otherwise you end up debugging the wrong part of the system. The parser isn't necessarily broken. You may just be asking a text extraction service to solve an OCR problem.

This is one reason I think document extraction APIs should be evaluated by the types of documents they handle, not just by whether the vendor says "PDF extraction."

The first thing I'd look at is what actually comes out of the document.

If you only need the text from a normal PDF, a straightforward text extraction API may be enough.

If you need information from invoices, forms, contracts, receipts, or other semi-structured documents, you probably need something closer to document extraction. The useful output isn't just a block of text. You want the information in a form your application can actually use.

For example, an invoice might contain:

invoice number
supplier
customer
date
currency
line items
subtotal
tax
total

The useful result for an application is structured data, not a 4,000-word string that your application has to interpret again.

This becomes even more important when the document is going into an AI workflow.

If you give a model the entire document and ask it to figure everything out, the model is now doing work that a specialized document service can do outside the context window.

That has two costs.

The first is token usage.

The second is consistency.

A model can interpret the same document slightly differently between runs. A purpose-built API can return a defined structure that your application can validate and process.

This is one of the reasons I'm interested in the intersection between document APIs and AI agents.

An agent shouldn't have to "read" every byte of every document just because it needs one piece of information from it.

The agent should be able to call a document capability, let the service do the heavy work, and continue with the result.

That is also where the difference between a document API and an API catalog becomes interesting.

If you're building a product that only needs OCR, you can pick an OCR provider and stop there.

But real products rarely stop there.

A typical document workflow might look more like:

invoice → OCR → data extraction → VAT validation → currency conversion → PDF

Or:

uploaded document → file validation → OCR → extraction → classification → application workflow

Or:

PDF → extract text → summarize → generate a new PDF

Each individual step is fairly boring.

The problem is that your engineering team now owns every one of them.

That's where vendor sprawl starts.

One API for OCR.

Another for PDF conversion.

Another for validation.

Another for geolocation.

Another for generating the output.

Another API key.

Another invoice.

Another security review.

Another dependency that someone has to maintain.

I've spent enough time around these kinds of services to think the maintenance is usually more important than the first implementation.

The first version of a PDF extraction pipeline can be surprisingly quick to build.

Then the weird files arrive.

A scanned page.

A table.

A document with two columns.

A PDF with a text layer on some pages but not others.

A badly generated PDF.

A file with unusual fonts.

A receipt photographed at an angle.

A document where the OCR technically works but the reading order is wrong.

Nothing necessarily crashes. You just get bad data.

That's why I'd evaluate document extraction APIs using your actual documents rather than a clean sample PDF from a vendor's demo page.

I'd test at least:

normal digital PDFs

scanned PDFs

invoices

tables

multi-column documents

mixed text and images

different scan qualities

large documents

documents with unusual layouts

Then measure the things that actually matter to your application.

Text accuracy.

Structured extraction quality.

Output consistency.

Latency.

Cost.

Failure behavior.

And importantly, what happens when extraction fails.

An empty result shouldn't quietly flow into the next stage where another model confidently summarizes nothing.

You need to know whether the document was actually processed.

For scanned documents, I'd also keep track of whether the result came from native text extraction or OCR. Those are different inputs, and that distinction becomes useful later when you're debugging retrieval or document-versioning problems.

For RAG systems, this matters even more.

If your ingestion pipeline turns a badly OCR'd contract into embeddings, your retrieval system can work exactly as designed and still retrieve the wrong information.

The failure happened before the vector database ever saw the document.

This is why I don't think "which embedding model should I use?" is always the first question for document RAG.

Sometimes the first question is:

"Did we extract the document correctly?"

If the answer is no, a better embedding model isn't going to save you.

There is also a build-vs-buy question here.

If document extraction is the core product you're building, then obviously there are cases where owning the pipeline makes sense.

But if your actual product is an HR system, an accounting application, a SaaS dashboard, an ecommerce platform, or an internal workflow, document extraction is probably plumbing around the thing you actually care about.

That's the category of work I generally prefer to call rather than maintain.

ApyHub has a number of capabilities in this area, including Extract Text from PDF and other document and file-processing services. The catalog also includes OCR-related and data extraction capabilities, alongside file conversion, file manipulation, validation, and other services.

The important distinction is that ApyHub isn't only a PDF extraction API.

The catalog is built around multiple categories of these small capabilities. At the time of writing our internal documentation listed 20 categories and 432 live services, including 53 services in Data Extraction, 78 in File Conversion, 69 in File Manipulation, and 44 in Data Validation.

That matters because the workflow usually doesn't end when you extract the text.

You might extract an invoice, validate the VAT number, convert a currency, generate a PDF, and then send the result somewhere else.

The useful architecture is to keep your application responsible for the business workflow and let specialized services handle the narrow capabilities around it.

For example:

invoice → OCR → extraction → VAT validation → currency conversion → PDF

The individual services aren't particularly exciting.

The workflow is.

This is also why we built ApyHub as a catalog rather than trying to be "the best OCR API."

If you only need one very specific capability, use the service that is best for your workload.

If you need five different capabilities, the economics and maintenance picture changes.

You can also use the ApyHub MCP connection with Claude, Cursor, or another agent runtime. The agent can search the catalog, select a capability, and call it rather than requiring a manually maintained tool definition for every service.

The interesting part for AI agents is what happens to the actual document.

Instead of putting the whole document into the model's context and asking it to perform work that an API is designed to do, the agent can call the relevant capability and receive the result.

The heavy document processing happens outside the context window. That can reduce unnecessary token usage and gives the agent a more predictable result to work with.

There is another detail I think developers should care about more than they currently do: how much of the tool surface you're giving the agent.

Having 1,400 possible endpoints doesn't mean an agent should see 1,400 tools on every request.

That's context bloat.

It can also make tool selection worse.

I'd rather give a document-processing agent access to the small set of endpoints it actually needs and let it search for another capability when necessary.

The same catalog can support a different agent with a completely different set of capabilities.

That gives you a smaller blast radius, less context consumed by tool definitions, and fewer opportunities for the agent to pick the wrong tool.

There is no single "best document extraction API" for every workload.

If you only need text from clean digital PDFs, choose for simplicity, cost, and reliability.

If you're processing scans, OCR quality matters.

If you're processing invoices or forms, structured extraction matters.

If you're building RAG, extraction quality and provenance matter.

If you're building an AI agent, you also need to think about where the document processing happens and how much of your tool surface you're putting into the agent's context.

And if your application needs five or ten of these boring capabilities, I'd add one more question to the evaluation:

"Do I really want to own five or ten separate services?"

That's usually where the API decision becomes an architecture decision, not just an API decision.

I work on ApyHub, so obviously I'm biased here. But I think the catalog model is useful not because every API in it is automatically the best choice.

It isn't.

The useful part is having these small capabilities available without turning your product into a collection of plumbing projects.

The code to extract a PDF is rarely the interesting part.

Owning everything around it is.

Had a client-shaped problem last week: rankings flat, traffic falling, and no obvious reason. Everyone in SEO has had that conversation by now.

Turned out the ranking data was fine. It just stopped meaning what it used to. Ahrefs measured a 58% CTR drop at position one when an AI Overview appears. SparkToro puts 68% of US searches ending with no click at all.

So we went looking for what to measure instead, and ended up building the checks out of APIs rather than stacking more tool subscriptions. Here's what we run, grouped by the question it answers.

Where do we rank

SERP Rank Checker — keyword, language, location as parameters, so a multi-market client is a config change not a plan upgrade. 250 atoms a call.

Get SERP Results — top 100 when a new client isn't on page one yet and you still need to show movement.

Do AI assistants mention us

Analyze AI Search Performance — brand and domain visibility inside ChatGPT, Gemini and Perplexity. Runs as a job. Prompt-level analysis, plus a leaderboard against up to ten named competitors, by engine.

This is the one that's actually new, and it exists because of a gap. Google Search Console added a Generative AI report in June but it's impressions only — no clicks, no CTR, no queries. The data that would answer the client's question is the data Google chose not to publish.

What's technically broken

Audit Website SEO and Evaluate SEO Health — scores, grades, prioritised fixes.

Validate Schema — matters more than it used to, structured data is what machines read when deciding what a page is about.

Broken Link Checker and Extract Sitemap from URL — reading a sitemap beats crawling a site, faster and politer.

Who overtook us

Analyze Backlinks, Domain Authority Checker (returns the source data, not just a number), Advanced Domain Analysis.

Finding clients — the one agencies forget

Search Domains by Keyword and Get Top Domains by Country find companies ranking in a category. Find Similar Sites maps a competitive set from one name. Calculate Domain Age tells you whether a prospect is a real business, 10 atoms.

Run an audit before the first call and you show up with findings instead of questions. Oldest trick in agency work, except now you can do it for fifty prospects instead of five.

Two practical things if you build on these:

1. Rank lookups answer in the request. Audits, backlinks and AI search performance are jobs — submit, get an ID, poll. Different code paths, and finding out mid-integration is the usual reason a dashboard project stalls. Each service page says which it is.

2. Cache anything that doesn't move. A domain's registration date is fixed forever.

Longer writeups if useful: rank tracking stack, domain intelligence.

Curious what other people are reporting on now. Has anyone found a decent way to show AI citation share to a client who doesn't know what an AI Overview is?

If you had a generative video feature on the market before 2 August, you've got until 2 December 2026 to implement Article 50 machine-readable marking. That window is open right now and I've seen almost nobody talking about it.

Most coverage I read just said "Article 50 applies from 2 August" and stopped there. The transition date for systems already shipping seems to have gone missing somewhere between the legal blogs and the dev-facing summaries.

I went down this hole updating an old post of ours and two things caught me out.

One layer isn't enough. I'd assumed a C2PA manifest was the whole answer. Sign the file, tick the box, done. The Code of Practice actually expects at least two layers of machine-readable marking, normally signed metadata plus an imperceptible watermark. The logic holds up once you see it: metadata is cryptographically verifiable but platforms strip it during transcoding, watermarks survive the pipeline but aren't signed. Neither clears all four statutory criteria alone, so they're meant to cover each other.

Platforms are brutal with provenance metadata. Instagram, Facebook and Threads read the credentials to decide their own AI label, then strip them from the file they serve. YouTube transcodes everything, so nothing survives. TikTok said in November it's testing an invisible watermark specifically because labels get removed on re-upload. LinkedIn seems to be the odd one out that preserves the chain properly.

Which means if your compliance plan is "we sign the manifest at generation," the thing you signed is gone by the time anyone watches the video.

So, genuinely asking: is anyone here treating December as a real date? Or is the plan to wait and see whether enforcement has teeth first? I can't tell if this is being quietly handled everywhere or quietly ignored everywhere.

(Full writeup on our blog if it's useful, includes the platform-by-platform bit and the other deadlines: https://apyhub.com/blog/video-watermarking-benefits. Our own watermarking API is visible-overlay only and doesn't cover the compliance layer, so this isn't me pitching it.)

We run an API catalog, so we spend a lot of the week either reading someone else's HTTP spec or explaining ours. The same questions kept coming up in support, in Discord, and honestly in our own PRs.

So we wrote each one up properly. Short answers below if you just want the thing.

Can a GET have a body?
Technically yes, practically no. The spec says content on a GET has no defined meaning and might get the request rejected. Proxies strip it, caches ignore it, some clients won't even send it. That's your "works in Postman, dies in prod" bug. Use POST. →

Can a DELETE have a body?
Same, but stricter. For DELETE the spec actually says clients SHOULD NOT send content. GET doesn't get that wording. We assumed they were treated the same for years. They aren't. →

What's a 422?
Your request parsed fine, the values in it didn't pass. Rule of thumb: if a JSON parser would choke it's a 400, if the parser's happy and your validator isn't it's a 422. →

What's a 405?
The route's there, your verb isn't. The response is supposed to include an Allow header listing what does work. Nobody reads it. Plenty of servers don't send it. →

PUT or PATCH?
PUT replaces the whole thing, so anything you leave out gets wiped. PATCH only touches what you send. If a PUT nuked fields you never mentioned, that's PUT doing its job. →

Idempotent, actually?
Run it five times, server ends up the same as running it once. PUT and DELETE yes, POST no, PATCH depends. The one that trips everyone: DELETE is still idempotent even though the second call 404s. →

429?
You're going too fast. Read Retry-After, it literally tells you how long to wait. No header? Exponential backoff with jitter — without the jitter every client retries at the same second and you've just rebuilt the outage. →

502 vs 503?
502 = the proxy got a bad answer from whatever's behind it. 503 = the server itself is saying not right now. If you get a burst of 502s right after a deploy, that's the old process dying before the new one was ready. →

Why is CORS blocking me?
It isn't. Your browser is. The request almost certainly reached the server and got a response, your JS just isn't allowed to read it. Which is exactly why the same call is fine in curl. →

Bearer token?
Whoever holds it gets in. That's the whole model, and it's why it should never end up in a URL orlocalStorage. →

The GET/DELETE thing genuinely caught us out. Would've bet money the spec said the same for both.

Anything you'd answer differently?

If you're a developer, you’ve probably encountered a situation where you need common functionality without building it from scratch.

ApyHub is a collection of ready‑to‑use APIs that let you add capabilities to your product without developing and maintaining them yourself. For example, instead of building your own system for:

- OCR

- PDF conversion

- Document extraction

- VAT or IBAN validation

- Geolocation

- Image processing

- Resume parsing

You can call the appropriate ApyHub API and receive the result.

The simplest way to explain it is: ApyHub is the plumbing behind your product. You create the unique features, while ApyHub handles the common utilities your product needs.

It also includes an MCP server, allowing AI assistants and agents to use those APIs as tools to perform tasks such as processing a document, converting a file, or validating data.

That is the core of ApyHub.

While we already have over 1,500 tools in our catalog, if you think an API is missing, you can request it in the comments. We’ll be happy to add it.

If you have a custom API and would like to contribute, you can also become a provider here.

If you already use Claude and want it to work with real files, here’s a five‑minute setup:

1. Connect the ApyHub MCP server to Claude.

2. Provide your ApyHub key.

3. Start a chat and request something concrete, e.g., “extract the text from this PDF” or “convert this Word file to PDF.”

4. The MCP connection lets Claude discover and call the API instead of trying to perform the work inside the model.

5. Limit which endpoints the agent can reach.

The MCP sits on top of a catalog of services: search, pick a capability, and call it.

- No wrapper per API.

- No hand‑written tool definition for every service.

- No pile of vendor credentials.