README.md

---
license: cc-by-4.0
pretty_name: NativePort Web-Access API Benchmarks
language:
  - en
tags:
  - benchmark
  - web-search
  - web-scraping
  - browser-automation
  - agents
  - tool-use
  - api-evaluation
  - latency
  - cost
size_categories:
  - n<1K
configs:
  - config_name: metric_rows
    data_files:
      - split: train
        path: data/metric_rows.jsonl
  - config_name: evaluations
    data_files:
      - split: train
        path: data/benchmarks.jsonl
---

# NativePort Web-Access API Benchmarks

Measured quality, latency, cost and error-rate figures for **22 commercial web-access
APIs** — search, SERP, scraping, crawling, extraction, sourced answers, screenshots,
document parsing, browser actions and change watching — scored per capability on a
fixed task corpus. This is the `2026-08-05` run: **67 provider × capability
scorecards** across **13 capabilities**, flattened into **297 metric rows**.

It exists for one practical decision: *when an AI agent needs to reach the live web,
which API should the call go to, and what will that cost in latency and dollars?*
Composite scores alone rarely answer that. The raw per-metric values do, and they are
all here.

## Disclosure

This dataset is produced by **NativePort** from its **own first-party benchmark
runs**. NativePort operates a commercial gateway that routes to many of the providers
scored here. It is **not an independent third-party evaluation**, and it should not be
cited as one. The measurement protocol, including what NativePort explicitly declines
to claim, is published in full (linked under [Methodology](#methodology)) so readers
can weigh the numbers accordingly. Weak and last-place results are published
unchanged — three scorecards in this snapshot sit below 2.0 out of 10, and two record a
100% error rate.

## Dataset structure

Two configs, two views of the same 67 scorecards. Nothing is aggregated or re-scored
between them.

| Config | File | Records | Grain |
| --- | --- | --- | --- |
| `metric_rows` | `data/metric_rows.jsonl` | 297 | one record per provider × capability × metric (tidy/long) |
| `evaluations` | `data/benchmarks.jsonl` | 67 | one record per provider × capability, metrics nested |

Both configs are JSONL deliberately. The Hub resolves a single packaged loader for the
whole repository from the declared config data files and then applies it to every
config, so a repository that mixes formats across its configs ends up parsing one of
them with the other's reader.

Two more files ship alongside them and back no config:

| File | Rows | What it is |
| --- | --- | --- |
| `data/benchmarks.csv` | 297 | the tidy view as CSV — same rows, same field order, same values as `data/metric_rows.jsonl` |
| `data/summary.json` | — | computed snapshot facts: counts, date range, source hash, per-capability and per-metric inventories, artifact digests |

`data/benchmarks.csv` is a download rather than a config. `load_dataset` never reads it,
but `pd.read_csv("hf://datasets/nativeport/web-access-api-benchmarks/data/benchmarks.csv")`,
`huggingface_hub.hf_hub_download` and a plain browser download all do. Both tidy files
are written in one pass from one row builder, so they cannot drift; the test suite
compares them field by field across all 297 rows, including the exact text of every
number. Every figure in `data/summary.json` is derived by the generator, never typed.

### `data/metric_rows.jsonl` and `data/benchmarks.csv` — tidy metric rows

Both carry these 23 fields, in this order:

| Field | Type | Description |
| --- | --- | --- |
| `evaluation_id` | string | `{provider_id}:{capability_id}`, unique per scorecard |
| `provider_id` | string | Provider slug as published by the source |
| `provider_name` | string | Display name, e.g. `Firecrawl` |
| `provider_group` | string | `Search`, `Scraping & Crawling` or `Browser Automation` |
| `provider_category` | string | Source's short category, e.g. `Google SERP scrape` |
| `capability_id` | string | Capability slug, e.g. `search`, `scrape`, `extract_ai` |
| `capability_label` | string | Human label, e.g. `Extract · AI/schema` |
| `metric_key` | string | Metric identifier, e.g. `recall_at_10` |
| `metric_label` | string | Source's short label for the metric |
| `metric_raw` | number | **The measured value**, copied verbatim from the source |
| `metric_display` | string | Source's formatted rendering, e.g. `816 ms`, `$0.0003 / call` |
| `metric_index` | int | Position of this metric within its scorecard (source order) |
| `composite_score` | number | Scorecard composite for this provider × capability |
| `composite_scale_max` | int | `10` for every row |
| `rank` | int | Rank within the capability, 1 = best |
| `rank_of` | int | Number of providers ranked in that capability |
| `is_capability_top` | bool | `true` where `rank == 1` |
| `measured_date` | date | Date of the run that produced this scorecard |
| `note` | string | Source's scorecard note; empty string where absent |
| `provider_page_url` | url | Public scorecard page for this provider |
| `run_id` | string | Benchmark run identifier (`2026-08-05`) |
| `source_url` | url | `https://nativeport.ai/evals.json` |
| `snapshot_sha256` | string | SHA-256 of the exact source snapshot these rows came from |

In `data/metric_rows.jsonl` the types above are the JSON types: `metric_raw` and
`composite_score` are JSON numbers, `metric_index` / `rank` / `rank_of` /
`composite_scale_max` are integers, and `is_capability_top` is a boolean. CSV has no
types, so `data/benchmarks.csv` carries the same values as text — numbers written as
the exact source token, booleans as `true` / `false`.

Provenance fields repeat on every row so that a filtered slice stays interpretable
and verifiable on its own.

```json
{
  "evaluation_id": "serper:serp",
  "provider_id": "serper",
  "provider_name": "Serper",
  "provider_group": "Search",
  "provider_category": "Google SERP scrape",
  "capability_id": "serp",
  "capability_label": "SERP verticals",
  "metric_key": "latency_p50_ms",
  "metric_label": "Latency p50",
  "metric_raw": 886.0,
  "metric_display": "886 ms",
  "metric_index": 1,
  "composite_score": 9.13,
  "composite_scale_max": 10,
  "rank": 1,
  "rank_of": 4,
  "is_capability_top": true,
  "measured_date": "2026-08-05",
  "note": "Lowest cost and latency; Google only.",
  "provider_page_url": "https://nativeport.ai/providers/serper/",
  "run_id": "2026-08-05",
  "source_url": "https://nativeport.ai/evals.json",
  "snapshot_sha256": "f46bf416803d5adf696c66ac14a6cbf06f4dfa39727cca164e8f3872abd6ed9b"
}
```

### `data/benchmarks.jsonl` — one record per evaluation

```json
{
  "evaluation_id": "serper:serp",
  "provider_id": "serper",
  "provider_name": "Serper",
  "provider_group": "Search",
  "provider_category": "Google SERP scrape",
  "capability_id": "serp",
  "capability_label": "SERP verticals",
  "capability_description": "Google SERP verticals (web, news, images, places, scholar) as structured JSON",
  "composite_score": 9.13,
  "composite_scale_max": 10,
  "rank": 1,
  "rank_of": 4,
  "is_capability_top": true,
  "measured_date": "2026-08-05",
  "note": "Lowest cost and latency; Google only.",
  "metric_count": 4,
  "metrics": [
    {"metric_index": 0, "metric_key": "quality", "metric_label": "Quality", "raw_value": 0.938, "display_value": "0.94"},
    {"metric_index": 1, "metric_key": "latency_p50_ms", "metric_label": "Latency p50", "raw_value": 886.0, "display_value": "886 ms"},
    {"metric_index": 2, "metric_key": "cost_per_call_usd", "metric_label": "Cost", "raw_value": 0.0003, "display_value": "$0.0003 / call"},
    {"metric_index": 3, "metric_key": "error_rate_pct", "metric_label": "Errors", "raw_value": 0.0, "display_value": "0%"}
  ],
  "provider_page_url": "https://nativeport.ai/providers/serper/",
  "run_id": "2026-08-05",
  "source_url": "https://nativeport.ai/evals.json",
  "source_schema_version": 1,
  "snapshot_sha256": "f46bf416803d5adf696c66ac14a6cbf06f4dfa39727cca164e8f3872abd6ed9b"
}
```

`metrics` is a **list of structs**, not a key-value map, because metric sets differ by
capability — a map would force a sparse union column across the whole dataset.

### Capabilities in this snapshot

Each capability is a separate leaderboard with its own task corpus, its own quality
metric and its own cost denominator.

| `capability_id` | Label | Evaluations | Metric rows | Metric keys |
| --- | --- | --- | --- | --- |
| `act` | Act · declarative | 6 | 24 | `cost_per_call_usd`, `error_rate_pct`, `latency_p50_ms`, `task_success` |
| `act_agent` | Act · NL-agent | 1 | 4 | `cost_per_call_usd`, `error_rate_pct`, `latency_p50_ms`, `task_success` |
| `answer` | Answer | 6 | 30 | `answer_correctness`, `citation_faithfulness`, `cost_per_call_usd`, `error_rate_pct`, `latency_p50_ms` |
| `crawl` | Crawl | 4 | 16 | `coverage`, `cost_per_useful_usd`, `error_rate_pct`, `latency_p50_ms` |
| `extract_ai` | Extract · AI/schema | 4 | 16 | `field_accuracy`, `cost_per_useful_usd`, `error_rate_pct`, `latency_p50_ms` |
| `extract_rules` | Extract · CSS rules | 3 | 12 | `field_accuracy`, `cost_per_useful_usd`, `error_rate_pct`, `latency_p50_ms` |
| `parse` | Parse · PDF/doc | 3 | 12 | `text_accuracy`, `cost_per_useful_usd`, `error_rate_pct`, `latency_p50_ms` |
| `scrape` | Scrape | 10 | 50 | `block_bypass_success_rate`, `markdown_cleanliness`, `cost_per_successful_page_usd`, `error_rate_pct`, `latency_p50_ms` |
| `scrape_domain` | Scrape-domain | 6 | 30 | `value_accuracy`, `field_fill`, `cost_per_useful_usd`, `error_rate_pct`, `latency_p50_ms` |
| `screenshot` | Screenshot | 8 | 38 | `valid_image_rate`, `full_page_support`, `cost_per_call_usd`, `error_rate_pct`, `latency_p50_ms` |
| `search` | Search | 11 | 44 | `recall_at_10`, `cost_per_useful_usd`, `error_rate_pct`, `latency_p50_ms` |
| `serp` | SERP verticals | 4 | 16 | `quality`, `cost_per_call_usd`, `error_rate_pct`, `latency_p50_ms` |
| `watch` | Watch | 1 | 5 | `classification_accuracy`, `diff_quality`, `cost_per_call_usd`, `error_rate_pct`, `latency_p50_ms` |

Metric sets are stable within a capability but **not guaranteed uniform**: one
`screenshot` scorecard carries three metrics rather than five — its source note records
that every capture errored, and no cost-per-call or full-page value is published for
it. Consumers should key on `metric_key` rather than on metric position or count, and
treat a missing metric as absent rather than as zero.

### Metric keys

| `metric_key` | Label | Occurrences | Direction | Unit |
| --- | --- | --- | --- | --- |
| `answer_correctness` | Correctness | 6 | higher is better | 0–1 |
| `block_bypass_success_rate` | Anti-bot bypass | 10 | higher is better | percent |
| `citation_faithfulness` | Citation faithfulness | 6 | higher is better | 0–1 |
| `classification_accuracy` | Class. accuracy | 1 | higher is better | 0–1 |
| `coverage` | Coverage | 4 | higher is better | 0–1 |
| `cost_per_call_usd` | Cost | 25 | lower is better | USD per call |
| `cost_per_successful_page_usd` | Cost | 10 | lower is better | USD per successful page |
| `cost_per_useful_usd` | Cost | 31 | lower is better | USD per useful result |
| `diff_quality` | Diff quality | 1 | higher is better | 0–1 |
| `error_rate_pct` | Errors | 67 | lower is better | percent |
| `field_accuracy` | Field accuracy | 7 | higher is better | 0–1 |
| `field_fill` | Field fill | 6 | higher is better | 0–1 |
| `full_page_support` | Full-page | 7 | higher is better | 0–1 |
| `latency_p50_ms` | Latency p50 | 67 | lower is better | milliseconds |
| `markdown_cleanliness` | Markdown clean | 10 | higher is better | 0–10 |
| `quality` | Quality | 4 | higher is better | 0–1 |
| `recall_at_10` | Recall@10 | 11 | higher is better | 0–1 |
| `task_success` | Task success | 7 | higher is better | 0–1 |
| `text_accuracy` | Text accuracy | 3 | higher is better | 0–1 |
| `valid_image_rate` | Valid image | 8 | higher is better | 0–1 |
| `value_accuracy` | Accuracy | 6 | higher is better | 0–1 |

Units and direction are read off the source's own `metric_display` strings (`816 ms`,
`$0.0003 / call`, `0%`, `3.4 / 10`); the machine-readable value always lives in
`metric_raw` / `raw_value`.

## Usage

```python
from datasets import load_dataset

rows = load_dataset("nativeport/web-access-api-benchmarks", "metric_rows", split="train")
evals = load_dataset("nativeport/web-access-api-benchmarks", "evaluations", split="train")
```

Both configs load as JSON Lines. `rows` has the 23 flat fields listed above, `evals` the
nested `metrics` list.

Cheapest search provider that clears a recall floor — the typical routing question,
answered from the tidy view with pandas:

```python
import pandas as pd

df = pd.read_json(
    "hf://datasets/nativeport/web-access-api-benchmarks/data/metric_rows.jsonl", lines=True
)
# The CSV mirror gives the same frame, for tools that prefer a spreadsheet:
# df = pd.read_csv("hf://datasets/nativeport/web-access-api-benchmarks/data/benchmarks.csv")

search = df[df.capability_id == "search"]

wide = search.pivot_table(
    index=["provider_id", "composite_score", "rank"],
    columns="metric_key",
    values="metric_raw",
).reset_index()

eligible = wide[(wide.recall_at_10 >= 0.55) & (wide.error_rate_pct == 0)]
print(eligible.sort_values("cost_per_useful_usd")[
    ["provider_id", "recall_at_10", "latency_p50_ms", "cost_per_useful_usd", "rank"]
])
```

The same query with no third-party dependencies, from the nested view:

```python
import json

with open("data/benchmarks.jsonl", encoding="utf-8") as handle:
    evaluations = [json.loads(line) for line in handle]

def metric(evaluation, key):
    for entry in evaluation["metrics"]:
        if entry["metric_key"] == key:
            return entry["raw_value"]
    return None

search = [e for e in evaluations if e["capability_id"] == "search"]
eligible = [e for e in search if metric(e, "recall_at_10") >= 0.55]
for evaluation in sorted(eligible, key=lambda e: metric(e, "cost_per_useful_usd")):
    print(
        evaluation["provider_id"],
        metric(evaluation, "recall_at_10"),
        f'{metric(evaluation, "latency_p50_ms"):.0f} ms',
        f'${metric(evaluation, "cost_per_useful_usd"):.5f}/useful',
    )
```

Two shapes worth knowing before you write a query:

- **Latency and cost are not comparable across capabilities.** A `serp` call and an
  `act_agent` call differ by three orders of magnitude in wall time by nature.
- **Cost denominators differ by capability.** `cost_per_call_usd` charges every
  attempt; `cost_per_useful_usd` and `cost_per_successful_page_usd` divide by usable
  output, so failures inflate them. Do not mix the three in one ordering.

## Methodology

Each capability has a versioned task corpus held fixed across every provider — the
same URLs, queries, target schemas and pass criteria — and four dimensions are
recorded per provider × capability pair: a capability-specific quality metric, median
wall-clock latency measured from the runner, track-specific cost computed from the
provider's real metered price, and error rate across the run. Where quality needs
judgment rather than string comparison, grading is done by an LLM panel working from
written rubrics. These fold into a composite out of 10, and providers are ranked
within each capability.

The full protocol — corpus construction, the four measured dimensions, how grading
works, and what NativePort explicitly does **not** claim (no uptime, SLA or
throughput figures) — is documented in
[How we measure](https://nativeport.ai/methodology/?utm_source=huggingface&utm_medium=referral&utm_campaign=backlink_hf_web_access_benchmarks_20260811).
Human-readable ranked tables per capability are at the
[leaderboards](https://nativeport.ai/leaderboards/).

The source snapshot summarises its own protocol as:

> One fixed task corpus per capability, identical for every provider; scorecards carry
> their run dates. Weak scores stay published, and the gateway's flat top-up fee means
> the ranking earns nothing from steering you toward pricier providers.

## Provenance and reproducibility

| Field | Value |
| --- | --- |
| Source | `https://nativeport.ai/evals.json` |
| Source schema version | `1` |
| Source SHA-256 | `f46bf416803d5adf696c66ac14a6cbf06f4dfa39727cca164e8f3872abd6ed9b` |
| Source size | 89894 bytes |
| Run | `2026-08-05` |
| Measured date range | `2026-08-05` to `2026-08-05` |

Rebuild the data files from that snapshot:

```bash
curl -sSfL https://nativeport.ai/evals.json -o evals.json
sha256sum evals.json          # must match the SHA-256 above
python3 scripts/build_dataset.py --input evals.json --output-dir data
```

`scripts/build_dataset.py` is standard-library-only and deterministic: identical input
bytes produce byte-identical outputs. No wall-clock timestamp is written anywhere, so
a rebuild can be diffed directly against the published files. Numeric values are
carried across as exact source tokens — the generator verifies that each emitted
number serialises character-for-character back to the token it read, and aborts rather
than emit a rounded stand-in. That same serialiser writes the CSV cell and the JSON
number, which is why the two tidy files agree token for token. `data/summary.json`
records the SHA-256 of all three data files, together with the config-to-file mapping
the front matter declares.

Fields present in the source but **excluded by design**: gateway routing and
authentication strings, list prices, latency prose, marketing summaries,
`choose_if` / `avoid_if` guidance, and catalog tier labels. Only benchmark
measurements and the provenance needed to interpret them are published here.

## Limitations and scope

- **Coverage is partial.** 22 of the 32 providers in the source catalog carry
  scorecards in this run; the other 10 have no eval entries and therefore no rows
  here. The source additionally flags 5 provider × capability pairs as unscored in
  this run. Absence from this dataset means *not measured in the `2026-08-05` run* —
  not "failed", and not "unavailable".
- **Composites are capability-local.** A composite is only meaningful against other
  providers in the same capability. A `9.13` on `serp` and a `9.13` on `scrape` are
  not the same achievement, and averaging a provider's composites across capabilities
  produces a number with no defined meaning.
- **Thin capabilities.** `act_agent` and `watch` contain a single scored provider
  each; `extract_rules` and `parse` contain three. A rank of 1 out of 1 is not
  evidence of superiority. Always read `rank_of` alongside `rank`.
- **Single point in time.** Every row in this snapshot was measured on `2026-08-05`.
  Provider behaviour, pricing and anti-bot posture change; these figures age.
- **First-party measurement.** Runs are operated by NativePort, which has a commercial
  relationship with providers in the catalog. See [Disclosure](#disclosure).
- **Judged metrics carry model bias.** Quality metrics that require judgment are
  graded by an LLM panel against rubrics, not by human annotators.
- **Not measured at all:** uptime, SLA conformance, throughput ceilings, regional
  performance, concurrency behaviour, and long-run stability. No row in this dataset
  speaks to any of them.
- **Cost is a measurement, not a quote.** Figures are computed from metered prices at
  run time for the calls in the corpus. They are not an offer, a rate card, or a
  prediction of any particular workload's bill.

## Update policy

- The dataset tracks NativePort benchmark runs. A new run publishes as a new revision
  of this repository, with `run_id`, `measured_date` and `snapshot_sha256` changing
  together.
- Prior revisions stay reachable through the repository's commit history; superseded
  numbers are not silently rewritten in place.
- Schema changes that are not backward compatible will be described in the commit that
  makes them and reflected in the tables above.
- File layout, for anyone who loaded an earlier revision: the `metric_rows` config is
  backed by `data/metric_rows.jsonl`. It previously pointed at `data/benchmarks.csv`,
  which left the two configs in different formats and made the Hub read one of them
  with the wrong parser. No row, field or measured value changed — only the file the
  config resolves to — and `data/benchmarks.csv` still ships, unchanged, as a download.
- No update cadence is promised here. `measured_date` and `run_id` are on every row
  precisely so a consumer can decide for itself whether the snapshot is still fresh
  enough to act on.

## Licensing

This dataset is licensed by NativePort under the **Creative Commons Attribution 4.0
International licence (CC BY 4.0)**.

| Field | Value |
| --- | --- |
| Licence | Creative Commons Attribution 4.0 International (CC BY 4.0) |
| Canonical licence URL | <https://creativecommons.org/licenses/by/4.0/> |
| Full legal code | <https://creativecommons.org/licenses/by/4.0/legalcode> — reproduced verbatim in [`LICENSE`](LICENSE) |
| SPDX identifier | `CC-BY-4.0` (Hub metadata key: `license: cc-by-4.0`) |

**What the licence covers.** NativePort licenses what it is in a position to license:
this dataset as a compilation — its selection, arrangement, schema, documentation and
this card — together with the benchmark measurements NativePort itself produced and
any database rights NativePort holds in them. The grant extends only to those rights
and only to the extent NativePort holds them. Where a jurisdiction treats an individual
measured figure as an unprotectable fact, the licence simply does not reach it: CC BY
4.0 places no conditions on a use that is lawful without permission (legal code
§ 2(a)(2) and § 8(a)). Where sui generis database rights do apply, § 4 of the legal
code grants extraction and reuse of all or a substantial part of the contents, subject
to the same attribution condition.

**What the licence does not cover.** CC BY 4.0 does not license patent or trademark
rights (legal code § 2(b)(2)). The provider, product and company names and marks that
appear in this dataset — including every mark listed under [Trademark
notice](#trademark-notice) — remain the property of their respective owners. They are
**not** licensed, sublicensed or otherwise granted to you here, by NativePort or by
this licence; NativePort has no authority to grant rights in another party's marks and
does not purport to. Reusing this dataset under CC BY 4.0 therefore gives you no right
to use those marks beyond whatever nominative, descriptive or fair use your own
jurisdiction independently allows. Nor does the licence permit you to assert or imply a
connection with, sponsorship by, or endorsement from NativePort as licensor
(legal code § 2(a)(6)); no trademark owner named here has endorsed, reviewed or
sponsored these results.

**Attribution.** Credit *NativePort*, name the dataset and the run (`2026-08-05`),
link to this repository or to `https://nativeport.ai/evals.json`, state that the
material is under CC BY 4.0 with a link to the licence, and indicate whether you
modified it. The [Citation](#citation) block below carries everything needed.

**No warranty.** The material is offered as-is and as-available, without warranties or
conditions of any kind, and NativePort's liability is limited, as set out in § 5 of the
legal code. Read it alongside [Limitations and scope](#limitations-and-scope): these
are measurements from one run on one date, not a guarantee of any provider's future
behaviour.

## Trademark notice

Provider names, product names and logos referenced here — including Serper, SerpApi,
SearchAPI.io, Brave Search, You.com, DataForSEO, Tavily, Exa, Linkup, Parallel, Jina,
ScraperAPI, Firecrawl, ScrapingBee, Scrapfly, ZenRows, Crawlbase, Oxylabs, Bright
Data, Spider, Zyte and Apify — are trademarks of their respective owners. They are
used here for identification and factual comparison only. Their appearance does not
imply any affiliation with, sponsorship by, endorsement by, or review of these results
by the trademark owners. NativePort is a trademark of its owner. Hugging Face is a
trademark of Hugging Face, Inc.

The CC BY 4.0 licence described under [Licensing](#licensing) grants **no** rights in
any of these marks — trademark rights are outside what that licence conveys (legal code
§ 2(b)(2)) and outside what NativePort could convey in the first place.

## Citation

```bibtex
@misc{nativeport_web_access_api_benchmarks_2026_08_05,
  title        = {NativePort Web-Access API Benchmarks},
  author       = {{NativePort}},
  year         = {2026},
  note         = {Benchmark run 2026-08-05; 67 provider-capability scorecards across 13 capabilities.
                  Source snapshot SHA-256 f46bf416803d5adf696c66ac14a6cbf06f4dfa39727cca164e8f3872abd6ed9b},
  license      = {CC BY 4.0, \url{https://creativecommons.org/licenses/by/4.0/}},
  howpublished = {\url{https://nativeport.ai/evals.json}}
}
```

Plain text: NativePort. *NativePort Web-Access API Benchmarks*, run `2026-08-05`.
Retrieved from `https://nativeport.ai/evals.json`. Licensed under CC BY 4.0
(<https://creativecommons.org/licenses/by/4.0/>); indicate if you modified it.