NativePort
Sign in Get a key
← How-to

How to Choose a Search API for AI Agents on NativePort

Brave, You.com, Parallel, Linkup, SerpApi and SearchAPI.io compared for agents — what each is, its NativePort route, and where Serper still wins on price.

“Search API” covers three genuinely different products, and mixing them up is the fastest way to build against the wrong one. A native-index engine (Brave, You.com’s Web Search, Parallel, Linkup) crawls and ranks the web itself. A SERP-scraping API (SerpApi, SearchAPI.io, and Serper, NativePort’s existing Google-focused baseline) fetches and structures another engine’s results page — usually Google’s. Some products blur the line by also offering AI-synthesized, cited answers on top of raw results. NativePort proxies seven of these under one key; this guide compares all seven fairly, sourced from each provider’s own documentation, and is explicit about which parts of each provider NativePort actually exposes — several of these providers ship broader APIs than what’s mounted here.

What you’ll need

  • A NativePort API key. Sign up to get a key and $5 in credits.
  • Python 3, standard library only — urllib.request, no pip install.
  • Your key exported as an environment variable, never hardcoded:
export NATIVEPORT_API_KEY="np_..."

Native-index search: Brave, You.com, Parallel, Linkup

These four run their own crawl or index rather than scraping another engine’s results — Brave’s own docs are explicit that it is “not a scraper that simply uses bots to query Google or Bing”, and Parallel similarly builds and ranks its own index rather than reselling another engine’s results.

Brave Search — an independently built index (30B+ pages, refreshed continuously), with a privacy-first sourcing story. NativePort mounts seven verticals as GET /brave/<vertical>/search: web, images, videos, news, suggest, spellcheck, summarizer (full list in Brave’s API documentation). Brave’s separate AI “Answers” endpoints are not mounted — Brave prices Answers as a per-request charge plus per-token charges for the summarization output, unlike Search’s flat per-request rate, which doesn’t fit this gateway’s flat metering. A single Brave request is capped at 20 results.

You.com — an independent index with a distinct raw-results Web Search API, separate from its own AI-synthesis products. NativePort mounts only GET /youcom/search — flat-priced, synchronous, up to 100 results per call. You.com’s Contents API (fetch-by-URL, priced per page fetched) and Research/Finance-Research APIs (multi-step, AI-synthesized, citation-backed, priced per effort tier) are not mounted: their cost is per-URL or per-effort-tier and variable, which a flat per-call meter can’t attribute cleanly. If your use case needs You.com’s synthesized research output specifically, that tier isn’t reachable through NativePort today.

Parallel — an index built around agent consumption: instead of a keyword query, you send a natural-language objective plus keyword queries, and get back ranked URLs with pre-compressed, token-dense excerpts rather than raw snippets or a full synthesized answer. NativePort mounts only POST /parallel/search. Parallel’s broader Task API (deep multi-hop research) is not mounted — it’s priced per processor tier from $5 (lite) to $300 (ultra) per 1,000 runs, a 60x spread, and runs asynchronously; neither fits a flat, synchronous per-call meter.

Linkup — an own-index search API that lets you tune which sources the index draws from. NativePort mounts only POST /linkup/search, but that one endpoint is more flexible than it sounds: an outputType field switches between raw searchResults, an AI-composed sourcedAnswer with citations, or structured output conformed to a JSON schema you supply, and a depth field (standard or deep) trades cost for a more thorough, multi-iteration search. Deep search runs roughly 10x the cost of standard — a real trade-off worth confirming you need before defaulting to it. Linkup’s separate /fetch (direct URL retrieval) and /research (higher-reasoning-depth) endpoints are not mounted.

Of these four, Linkup is the only one whose AI-synthesized answer tier is actually reachable through NativePort in one call — You.com’s and Parallel’s live on endpoints this gateway doesn’t mount.

SERP-scraping and aggregation: Serper, SerpApi, SearchAPI.io

These three fetch and structure an existing search engine’s real results page, rather than running their own index.

Serper is NativePort’s existing Google-focused baseline, already covered in its own guide: How to Use Serper Google Search Through NativePort. It’s Google-only, cheapest of the three, and the one most agent frameworks default to.

SerpApi scrapes and structures results from a wide roster of engines beyond Google — Bing, DuckDuckGo, Baidu, Yandex, Yahoo, plus marketplace/vertical engines like Amazon, eBay, YouTube and the app stores — with official SDKs across several languages. NativePort mounts the single search endpoint, GET /serpapi, with engine and every other control entirely client-controlled in the query string, exactly as if you called SerpApi directly.

SearchAPI.io covers a broad engine roster (spanning Google’s own verticals plus Bing, Baidu, Yandex, Amazon, YouTube and more), and documents billing only successful (200-status) searches rather than every attempt. NativePort mounts it the same shape as SerpApi: GET /searchapi, engine and q (and everything else) in the query string.

Making the calls

Every provider here shares the same key and Authorization: Bearer <NATIVEPORT_API_KEY> header — the difference is GET-with-query-string (Brave, You.com, SerpApi, SearchAPI.io) versus POST-with-JSON-body (Parallel, Linkup):

import json
import os
import urllib.parse
import urllib.request

GATEWAY = "https://api.nativeport.ai"
API_KEY = os.environ["NATIVEPORT_API_KEY"]


def get_search(path, params):
    qs = urllib.parse.urlencode(params)
    req = urllib.request.Request(f"{GATEWAY}{path}?{qs}", method="GET")
    req.add_header("Authorization", f"Bearer {API_KEY}")
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read())


def post_search(path, body):
    req = urllib.request.Request(
        f"{GATEWAY}{path}", data=json.dumps(body).encode(), method="POST"
    )
    req.add_header("Authorization", f"Bearer {API_KEY}")
    req.add_header("Content-Type", "application/json")
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read())


brave = get_search("/brave/web/search", {"q": "nativeport ai gateway"})
youcom = get_search("/youcom/search", {"query": "nativeport ai gateway"})
serpapi = get_search("/serpapi", {"engine": "google", "q": "nativeport ai gateway"})
searchapi = get_search("/searchapi", {"engine": "google", "q": "nativeport ai gateway"})

parallel = post_search("/parallel/search", {
    "objective": "find NativePort's gateway pricing model",
    "search_queries": ["nativeport ai gateway pricing"],
})

linkup = post_search("/linkup/search", {
    "q": "nativeport ai gateway",
    "depth": "standard",
    "outputType": "searchResults",
})

Each response is that provider’s own JSON, shaped exactly as their own documentation describes it — the gateway doesn’t reshape any of them, so treat each one’s schema as that provider’s to document, not NativePort’s.

Picking one

  • Google’s actual results, nothing more, cheapest: Serper.
  • Breadth across many engines beyond Google, official SDKs: SerpApi.
  • The same breadth, cheaper, billed only on success: SearchAPI.io.
  • An index independent of Google/Bing, with a privacy angle and verticals beyond plain web search: Brave.
  • Pre-compressed, agent-ready excerpts driven by a natural-language objective rather than a keyword string: Parallel.
  • A sourced, cited answer or schema-structured output from one call, without stitching results together yourself: Linkup (outputType: "sourcedAnswer" or "structured") — the one provider here whose answer tier NativePort actually mounts.
  • Raw web results with fine-grained domain include/exclude/boost controls: You.com.

For semantic, embeddings-driven discovery rather than any of the above — finding pages by meaning instead of keywords, or a dedicated find-similar action — see Exa instead; it’s a different search paradigm from every provider in this guide.

Errors you’ll actually hit

  • 402 Payment Required: the NativePort balance is at $0. Every request answers this deterministically, so top up and retry.
  • 401 Unauthorized: the Authorization: Bearer <NATIVEPORT_API_KEY> header is missing, malformed, or doesn’t resolve to an account.
  • 403 Forbidden: the key is valid but the account isn’t active.
  • 404: a path outside what’s listed above — most often reaching for a broader endpoint one of these providers offers that NativePort doesn’t mount (You.com’s Research API, Parallel’s Task API, Linkup’s /fetch or /research, Brave’s Answers endpoints). Check the exclusions above before assuming a typo.
  • Provider-specific 400/422: a malformed query or body for that provider — missing q/query, or in Parallel’s case a missing search_queries array. Each provider validates its own request shape; the gateway doesn’t pre-check it for you.
  • A 200 with an empty results array: the provider itself found nothing, not a gateway fault.

Security

Treat NATIVEPORT_API_KEY like any other credential: environment variable or secret store, never a literal string in source, never logged. None of these seven providers’ own credentials ever reach your process — the gateway injects each one server-side.

What this costs

Six of these seven bill flat per accepted request (Brave, You.com, Parallel, Linkup, SerpApi, SearchAPI.io); Serper is metered from the credit count its own response reports, which varies by vertical. None of it carries a NativePort markup — current per-request pricing for each lives on its own provider page (Brave, You.com, Parallel, Linkup, SerpApi, SearchAPI.io, Serper) rather than restated here, since rates move. A zero balance answers every request with 402 instead of degrading. Adding credit carries a flat 5.5% fee on top-ups between $10 and $5,000 — never on the calls themselves. Full breakdown: pricing.

Where to go next