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

# Download every dataset as a zip of Parquet files



## OpenAPI

````yaml /openapi/openapi.yaml get /api/v1/export/dataville.parquet.zip
openapi: 3.0.3
info:
  title: Dataville API
  version: 1.0.0
  description: >
    Dataville is a unified data API: a single REST surface over Wikipedia,
    arXiv,

    Project Gutenberg, the US Census, USDA FoodData, Papers with Code, SEC
    EDGAR,

    OpenAlex, PyPI and Stack Exchange — plus bulk CSV/Parquet/DuckDB export, a

    SQL endpoint, and "bring your own data" Google Sheets connections.


    ## Authentication


    Data, export and query endpoints never hard-reject at the middleware level —
    an

    unauthenticated caller simply gets the anonymous tier (50 requests per day
    per

    IP).


    ### API key


    ```

    Authorization: Bearer dataville_xxxxxxxxxxxxxxxx

    ```


    Create and manage keys from the **API Keys** page in the

    [Dataville dashboard](https://app.dataville.com). Keys start with
    `dataville_`

    (legacy keys start with `datax_`). For clients that cannot set headers —
    DuckDB

    WASM, the DuckDB CLI's `httpfs` reader — the same key may be passed as the

    `?token=` query parameter.


    The Dataville web app authenticates with its own session tokens; those
    routes

    are internal and not part of the public API surface.


    ## Credits and metering


    Authenticated usage is metered against a monthly **Dataville credit**
    balance in

    USD, shared across an account's sessions and API keys. Each tier is granted

    credit every month — Free **$5**, Developer **$29**, Pro **$99** — and each

    query deducts a per-source, per-tier amount:


    | Class | Free | Developer | Pro |

    | --- | --- | --- | --- |

    | Open/public datasets | $0.0050 | $0.0050 | $0.0040 |

    | Wikipedia (premium) | $0.0250 | $0.0150 | $0.0125 |


    A `POST /api/v1/query` call is charged per row returned. When the balance

    reaches zero the API returns **402 Payment Required** until the monthly
    reset,

    a plan upgrade, or a credit top-off. Every metered response carries:


    - `X-Credits-Remaining` — remaining balance, USD

    - `X-Credit-Cost` — amount charged for this request, USD


    Check your request quota any time via `GET /api/v1/auth/usage`; your credit

    balance is reported on every metered response in `X-Credits-Remaining` and
    on

    the dashboard's **Billing** page.


    ## Rate limiting


    Anonymous callers are limited by IP (50 requests per 24 hours) and receive

    **429** when they exceed it, with `X-RateLimit-Limit`,
    `X-RateLimit-Remaining`

    and `X-RateLimit-Reset` headers. Authenticated callers are governed by
    credits

    rather than a request count. Export and SQL routes carry their own stricter

    limit (1,000 per day per account), as does support submission (5 per hour).


    ## Errors


    Every error body carries a human-readable `error`/`message` string that is
    safe

    to show a user verbatim, and data-source errors additionally carry a stable

    `data.code` (`UPSTREAM_RATE_LIMITED`, `UPSTREAM_UNAVAILABLE`,

    `UPSTREAM_FORBIDDEN`, `UPSTREAM_BAD_RESPONSE`, `SOURCE_UNAVAILABLE`,

    `INTERNAL_ERROR`) that clients should branch on instead of parsing prose.
    When

    an upstream tells us how long to wait, the response sets `Retry-After`.


    ## Stale results


    A live source that is down is answered from Dataville's own stored copy
    where

    one exists. Those responses include a `data.stale` object naming the source
    and

    when the copy was taken — the answer is real, but may be out of date.
  contact:
    name: Dataville Support
    email: support@dataville.com
  license:
    name: MIT
    url: https://opensource.org/licenses/MIT
servers:
  - url: https://api.dataville.com
    description: Production
security:
  - ApiKeyAuth: []
tags:
  - name: Data sources
    description: Keyword search and article lookup across every supported dataset.
  - name: Export and SQL
    description: Bulk CSV/Parquet/DuckDB download and SELECT-only SQL over the datasets.
  - name: Connected sheets
    description: Connect a Google Sheet and query it alongside the public datasets.
  - name: Usage
    description: |-
      Usage and quota for your API key (or your IP when anonymous). Keys
      are created and revoked from the dashboard's **API Keys** page.
paths:
  /api/v1/export/dataville.parquet.zip:
    get:
      tags:
        - Export and SQL
      summary: Download every dataset as a zip of Parquet files
      operationId: exportAllParquetZip
      parameters:
        - $ref: '#/components/parameters/TokenQuery'
      responses:
        '200':
          description: >
            Zip archive, one Parquet file per source.


            <h4>Response headers</h4>


            | Header | Example |

            | --- | --- |

            | `Content-Disposition` | `attachment;
            filename="dataville-parquet.zip"` |

            | `X-Dataville-Success` | `true` |

            | `X-Dataville-Message` | `dataville-parquet.zip downloaded
            successfully.` |

            | `RateLimit-Remaining` | `999` |


            The archive is streamed as it is built, so no `Content-Length` is

            sent.
          headers:
            X-Dataville-Success:
              schema:
                type: string
                example: 'true'
              description: >-
                Set to `true` when the archive was generated and streamed
                successfully.
            X-Dataville-Message:
              schema:
                type: string
                example: dataville-parquet.zip downloaded successfully.
              description: Human-readable confirmation of the download.
          content:
            application/zip:
              schema:
                type: string
                format: binary
                example: Binary file stream — dataville.parquet.zip
        '401':
          $ref: '#/components/responses/ExportUnauthorized'
        '402':
          $ref: '#/components/responses/InsufficientCredit'
        '429':
          $ref: '#/components/responses/ExportRateLimited'
components:
  parameters:
    TokenQuery:
      name: token
      in: query
      required: false
      description: |
        API key as a query parameter, for clients that cannot set an
        `Authorization` header (DuckDB WASM, the DuckDB CLI). Prefer the header
        wherever possible — query strings end up in logs.
      schema:
        type: string
  responses:
    ExportUnauthorized:
      description: Authentication required.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/SimpleError'
          example:
            status: error
            message: >-
              Authentication required. Include your API key in the Authorization
              header.
    InsufficientCredit:
      description: Monthly credit exhausted — upgrade, top off, or wait for the reset.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/InsufficientCreditResponse'
    ExportRateLimited:
      description: Export/query limit exceeded (1,000 per day per account).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/SimpleError'
          example:
            status: error
            message: >-
              Export rate limit exceeded. Maximum 1,000 exports per day per
              account.
  schemas:
    SimpleError:
      type: object
      properties:
        status:
          type: string
          enum:
            - error
        message:
          type: string
    InsufficientCreditResponse:
      type: object
      properties:
        status:
          type: string
          enum:
            - error
        account_state:
          type: string
          example: authenticated
        error:
          type: string
          example: insufficient_credit
        data:
          type: object
          properties:
            error:
              type: string
            code:
              type: string
              enum:
                - INSUFFICIENT_CREDIT
        credits:
          type: object
          properties:
            remaining_usd:
              type: number
              format: float
            request_cost_usd:
              type: number
              format: float
  securitySchemes:
    ApiKeyAuth:
      type: http
      scheme: bearer
      description: >
        A Dataville API key, sent as `Authorization: Bearer dataville_...`.
        Clients

        that cannot set headers may pass the same key as `?token=`.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.