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

# List Uploaded Tables

> Get a paginated list of uploaded tables

<Info>
  Minimum required API key scope: `Read`
</Info>

## Description

Retrieves a paginated list of tables uploaded by the user or their team.

<Tip>
  **Migrating from the old API?** This endpoint replaces the deprecated `GET /v1/tables`. See the [Migration Guide](./migration) for details.

  For broader dataset discovery including Dune community datasets, use the `/v1/datasets` endpoint.
</Tip>

## Pagination

Use the `limit` and `offset` parameters to paginate through large result sets:

* To get the first 20 tables: `?limit=20&offset=0`
* To get the next 20 tables: `?limit=20&offset=20`
* Continue incrementing `offset` by `limit` to get subsequent pages

## Pricing

This is a metadata endpoint and does not consume credits.

## Related Endpoints

* [Create Table](/api-reference/tables/endpoint/uploads-create) - Create a new table
* [Upload Data](/api-reference/tables/endpoint/uploads-csv) - Upload data to a table
* [Delete Table](/api-reference/tables/endpoint/uploads-delete) - Delete a table

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.dune.com/api/v1/uploads?limit=10&offset=0" \
    -H "X-DUNE-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.dune.com/api/v1/uploads"
  params = {
      "limit": 10,
      "offset": 0
  }
  headers = {"X-DUNE-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, params=params, headers=headers)
  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const url = 'https://api.dune.com/api/v1/uploads';
  const params = new URLSearchParams({
    limit: 10,
    offset: 0
  });

  const response = await fetch(`${url}?${params}`, {
    headers: {
      'X-DUNE-API-KEY': 'YOUR_API_KEY'
    }
  });

  const data = await response.json();
  console.log(data);
  ```
</RequestExample>

<ResponseExample>
  ```json Example Response theme={null}
  {
    "tables": [
      {
        "full_name": "dune.dune.ai_contract_tags",
        "is_private": true,
        "table_size_bytes": "1152622",
        "created_at": "2024-05-15T20:34:58.585Z",
        "updated_at": "2024-05-16T21:19:02.459Z",
        "purged_at": null,
        "owner": {
          "handle": "dune",
          "type": "team"
        },
        "columns": [
          {
            "name": "blockchain",
            "type": "string",
            "nullable": false,
            "metadata": {
              "description": "Blockchain associated with the record",
              "filtering_column": true
            }
          },
          {
            "name": "contract_address",
            "type": "string",
            "nullable": false,
            "metadata": {
              "description": "Address of the smart contract"
            }
          }
        ]
      }
    ]
  }
  ```
</ResponseExample>


## OpenAPI

````yaml GET /v1/uploads
openapi: 3.0.1
info:
  contact: {}
  description: Dune API
  title: DuneAPI
  version: '1.0'
servers:
  - url: https://api.dune.com/api
security: []
paths:
  /v1/uploads:
    get:
      summary: List all tables owned by the account
      description: >-
        Returns a paginated list of all tables owned by the authenticated
        account.
      parameters:
        - description: API Key for the service
          in: header
          name: X-Dune-Api-Key
          required: true
          schema:
            type: string
        - description: API Key, alternative to using the HTTP header X-Dune-Api-Key
          in: query
          name: api_key
          schema:
            type: string
        - description: 'Number of tables to return on a page. Default: 50, max: 10000'
          in: query
          name: limit
          schema:
            format: int32
            type: integer
        - description: Offset used for pagination. Negative values are treated as 0
          in: query
          name: offset
          schema:
            format: int32
            type: integer
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.TableListResponse'
          description: OK
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.Error400'
          description: Bad Request
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.Error401'
          description: Unauthorized
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/models.Error500'
          description: Internal Server Error
components:
  schemas:
    models.TableListResponse:
      properties:
        next_offset:
          description: Offset for next page of results
          type: integer
        tables:
          items:
            $ref: '#/components/schemas/models.TableListElement'
          type: array
      type: object
    models.Error400:
      properties:
        error:
          example: Bad Request
          type: string
      type: object
    models.Error401:
      properties:
        error:
          example: Invalid API Key
          type: string
      type: object
    models.Error500:
      properties:
        error:
          example: Internal error
          type: string
      type: object
    models.TableListElement:
      properties:
        columns:
          description: List of table columns
          items:
            $ref: '#/components/schemas/models.TableColumnInfo'
          type: array
        created_at:
          description: ISO 8601 timestamp of table creation
          type: string
        full_name:
          description: Fully qualified table name (catalog.schema.table)
          type: string
        is_private:
          description: Whether the table is private
          type: boolean
        owner:
          allOf:
            - $ref: '#/components/schemas/models.TableOwner'
          description: Owner information
        purged_at:
          description: ISO 8601 timestamp of when table was purged
          type: string
        table_size_bytes:
          description: Size of the table in bytes
          type: string
        updated_at:
          description: ISO 8601 timestamp of last update
          type: string
      type: object
    models.TableColumnInfo:
      properties:
        metadata:
          additionalProperties: {}
          description: Additional column metadata
          type: object
        name:
          description: Column name
          type: string
        nullable:
          description: Whether the column can contain null values
          type: boolean
        type:
          description: Column data type
          type: string
      type: object
    models.TableOwner:
      properties:
        handle:
          description: User or team identifier
          type: string
        type:
          description: Type of entity that created the table
          type: string
      type: object

````