> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://help.sigmacomputing.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://help.sigmacomputing.com/_mcp/server.

# List data models

GET https://api.sigmacomputing.com/v2/dataModels

This endpoint retrieves a list of all data models available. You can use the response from this endpoint to review existing data models and determine if there are duplicates or gaps.

### Usage notes

This endpoint requires no parameters for basic requests, but supports query parameters for pagination and response limit.

Users with the Admin account type can optionally retrieve all data models in the organization.

#### Pagination

This endpoint supports pagination, which lets you retrieve large sets of data in manageable segments. The response includes pagination details as follows:

* hasMore: A boolean value indicating whether there are more pages of data available beyond the current page.
* total: The total number of entries available across all pages.
* nextPage: An identifier or token that you can use in a subsequent request to retrieve the next page of data.

#### Example response for pagination

\{
"hasMore": true,
"total": 104,
"nextPage": "50"
}
To request additional pages, include the `nextPage` option in your followup request according to the endpoint's parameter requirements. This process can be repeated until the `nextPage` option returns `null`, indicating that no further data is available.

### Usage scenarios

* **Data model navigation:** Allows users to easily navigate through their available of data models and access the one they need.
* **Track lineage**: Identify dependencies and lineage of data sources and data models.

Reference: https://help.sigmacomputing.com/reference/list-data-models

## Authentication

- OAuth2 — send the obtained token as `Authorization: Bearer <token>`

## Servers

- `https://api.sigmacomputing.com` (Server for GCP (US) hosted organizations, default)
- `https://api.sa.gcp.sigmacomputing.com` (Server for GCP (KSA) hosted organizations)
- `https://aws-api.sigmacomputing.com` (Server for AWS US (West) hosted organizations)
- `https://api.us-a.aws.sigmacomputing.com` (Server for AWS US (East) hosted organizations)
- `https://api.ca.aws.sigmacomputing.com` (Server for AWS Canada hosted organizations)
- `https://api.eu.aws.sigmacomputing.com` (Server for AWS Europe hosted organizations)
- `https://api.au.aws.sigmacomputing.com` (Server for AWS Australia and APAC hosted organizations)
- `https://api.uk.aws.sigmacomputing.com` (Server for AWS UK hosted organizations)
- `https://api.us.azure.sigmacomputing.com` (Server for Azure US hosted organizations)
- `https://api.eu.azure.sigmacomputing.com` (Server for Azure Europe hosted organizations)
- `https://api.ca.azure.sigmacomputing.com` (Server for Azure Canada hosted organizations)
- `https://api.uk.azure.sigmacomputing.com` (Server for Azure United Kingdom hosted organizations)
- `https://api.au.azure.sigmacomputing.com` (Server for Azure Australia hosted organizations)

## Request

### Query parameters

- `page` (string, optional)
- `limit` (double, optional)
- `excludeTags` (boolean, optional)
- `skipPermissionCheck` (boolean, optional)

## Response

### 200

The response body.

- `entries` (list of object, required) — Array of results returned by the endpoint
  - `dataModelId` (string, required) — Unique identifier of the data model.
  - `dataModelUrlId` (string, required)
  - `name` (string, required)
  - `url` (string, required)
  - `path` (string, required)
  - `latestVersion` (double, required)
  - `ownerId` (string, required)
  - `createdBy` (string, required) — The identifier of the user who created this object.
  - `updatedBy` (string, required) — The identifier of the user or process that last updated this object.
  - `createdAt` (datetime, required) — When the object was created.
  - `updatedAt` (datetime, required) — When the object was last updated.
  - `isArchived` (boolean, optional)
  - `tags` (list of object, optional)
    - `versionTagId` (string, required) — Unique identifier of the tag.
    - `tagName` (string, required)
    - `sourceVersion` (double, required)
    - `taggedAt` (datetime, required)
- `nextPage` (string, required, nullable) — Returns a string that can be used as the `page` parameter in the next request to fetch the next page of results. The last page of results returns `null`.
- `total` (double, optional) — Total number of results. Useful to determine if there is a need to paginate.
- `hasMore` (boolean, optional) — **[Deprecated]** Indicates whether more results are available.

## Examples

**Response**

```json
{
  "entries": [
    {
      "dataModelId": "string",
      "dataModelUrlId": "string",
      "name": "string",
      "url": "string",
      "path": "string",
      "latestVersion": 1.1,
      "ownerId": "string",
      "createdBy": "string",
      "updatedBy": "string",
      "createdAt": "2024-01-15T09:30:00Z",
      "updatedAt": "2024-01-15T09:30:00Z",
      "isArchived": true,
      "tags": [
        {
          "versionTagId": "string",
          "tagName": "string",
          "sourceVersion": 1.1,
          "taggedAt": "2024-01-15T09:30:00Z"
        }
      ]
    }
  ],
  "nextPage": "string",
  "total": 1.1,
  "hasMore": true
}
```

**SDK Code**

```python
import requests

url = "https://api.sigmacomputing.com/v2/dataModels"

headers = {"Authorization": "<token>."}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.sigmacomputing.com/v2/dataModels';
const options = {method: 'GET', headers: {Authorization: '<token>.'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.sigmacomputing.com/v2/dataModels"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<token>.")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.sigmacomputing.com/v2/dataModels")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<token>.'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.sigmacomputing.com/v2/dataModels")
  .header("Authorization", "<token>.")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.sigmacomputing.com/v2/dataModels', [
  'headers' => [
    'Authorization' => '<token>.',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.sigmacomputing.com/v2/dataModels");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<token>.");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "<token>."]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.sigmacomputing.com/v2/dataModels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```