> ## Documentation Index
> Fetch the complete documentation index at: https://docs.uapi.nl/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> Extract structured JSON from any website with a single API call or SDK

uAPI is a universal data access layer for the web. It turns arbitrary web pages into normalized, schema-aligned JSON with stable field names, ISO 8601 timestamps, and clean value types. You integrate once—via HTTPS or official SDKs—and get consistent output without managing scrapers, proxies, or anti-bot systems.

<Card title="Start under a minute" icon="rocket" href="/quickstart" horizontal>
  Install the SDK, add your API key, call /v1/extract, and read normalized JSON.
</Card>

<Columns cols={2}>
  <Card title="Authentication" icon="key-round" href="/reference/authentication">
    Authenticate every request with the X-API-Key header.
  </Card>

  <Card title="Responses" icon="message-square-more" href="/reference/responses">
    Learn the standard envelope, request metadata, and how to log it.
  </Card>

  <Card title="Caching" icon="rabbit" href="/reference/caching">
    Control freshness per key with the x-cache-ttl header.
  </Card>

  <Card title="Errors" icon="siren" href="/reference/errors">
    Stable error codes, messages, and HTTP statuses for robust handling.
  </Card>

  <Card title="Types" icon="database" href="/reference/types">
    Field types and normalization guarantees across targets.
  </Card>

  <Card title="Changelog" icon="history" href="/resources/changelog">
    Track behavior and compatibility across uAPI releases.
  </Card>
</Columns>

## What you get on every call

Every endpoint returns the same stable envelope.

You always receive:
id for correlation and support.
success to indicate whether structured data is available.
data containing the normalized payload when success is true.
error containing a stable code and message when success is false.
uapi\_version and schema\_version for compatibility tracking.
request with endpoint, method, parameters, timestamps, status\_code, and cache\_info.
deprecation\_warnings as a non-breaking channel for upcoming changes.

Billing and usage are handled account-side; your integration logic stays focused on success, data, and error.

<Note>
  Authentication is a single header: X-API-Key. No additional auth headers are required.
</Note>

## Try it now with the SDKs

The fastest way to see uAPI in action is to extract structured data from a public URL using the official clients.

<CodeGroup>
  ```python Python (usdk) theme={null}
  import os
  from uapi import uAPI  # provided by the usdk package

  client = uAPI(
      api_key=os.environ.get("UAPI_API_KEY"),  # or omit to use UAPI_API_KEY by default
  )

  response = client.extract(
      url="https://example.com",
  )

  print(response.to_dict())
  ```

  ```javascript Node.js / TypeScript (usdk-js) theme={null}
  import 'dotenv/config'
  import uAPI from 'usdk-js'

  const client = new uAPI({
    apiKey: process.env['UAPI_API_KEY'], // default: reads from env
  })

  const result = await client.extract({
    url: 'https://example.com',
  })

  console.log(result)
  ```

  ```bash cURL (raw HTTP) theme={null}
  curl -s "https://api.uapi.nl/v1/extract?url=https%3A%2F%2Fexample.com" \
    -H "X-API-Key: ${UAPI_API_KEY}"
  ```
</CodeGroup>

<Tip>
  Optionally send the x-cache-ttl header (0–3600) to cache successful GET responses for your own key. Caching is isolated per API key; other users cannot affect your cache.
</Tip>

## Why teams choose uAPI

Predictable integration: one schema-normalized API across heterogeneous sites, so your downstream models, analytics, and pipelines do not need per-site adapters.

Operational clarity: a single envelope with stable fields for logging, monitoring, and debugging. You can build alerts on success, error.code, and request.status\_code without chasing special cases.

Developer-first tooling: officially supported Python and TypeScript SDKs, typed responses, clear error surfaces, and docs that match real behavior.

## Next steps

Go to Quickstart to:
Create an API key.
Install the SDK for your stack.
Make your first `/v1/extract` and `/v1/search` calls.

Then:
Use the Endpoints pages for precise request/response contracts.
Read Responses and Types to lock in how you parse the envelope.
See Caching to tune x-cache-ttl for your workloads.
Review Our Pledge and Support to understand how we handle stability, fairness, and incident response.

<CardGroup cols={2}>
  <Card title="Get started fast" icon="rocket" href="/quickstart">
    From API key to first successful response in minutes.
  </Card>

  <Card title="Explore endpoints" icon="cloud" href="/endpoints/extract">
    Definitive reference for /v1/extract, /v1/search, and /v1/perform.
  </Card>
</CardGroup>