> This page is for version 2025-09-18 (default).
> For other versions, use one of these documentation indexes:
> - 2025-09-18 (default): https://apidocs.polytomic.com/2025-09-18/llms.txt
> - 2024-02-08: https://apidocs.polytomic.com/2024-02-08/llms.txt
> - 2023-04-25: https://apidocs.polytomic.com/2023-04-25/llms.txt
> - 2022-12-12: https://apidocs.polytomic.com/2022-12-12/llms.txt
> - 2021-05-23: https://apidocs.polytomic.com/2021-05-23/llms.txt

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

# Get Entity

GET https://app.polytomic.com/api/entities/{id}

Returns a resolved entity by ID.

Looks up a UUID within the caller's current organization and returns the
resource type plus enough context to fetch the canonical resource.

This endpoint is useful when you have an execution, sync, model, Connection,
Harbor, Harbor context, Organization, or user UUID and need to determine what
it refers to.

The response always includes:

- `id`: the UUID that was resolved.
- `type`: the resolved entity type.
- `canonical_path`: the canonical REST path for the resolved resource.

The response may also include:

- `relationships`: parent resources needed to address nested resources.
- `context`: lightweight additional context, such as bulk sync `schema_ids`.

For the normal user-scoped endpoint, `organization_id` is omitted from the
response.

Supported `type` values currently include:

- `organization`
- `user`
- `connection`
- `model`
- `model_sync`
- `model_sync_execution`
- `bulk_sync`
- `bulk_sync_execution`
- `harbor`
- `harbor_context`

Examples:

- A model sync execution resolves to a `model_sync_execution` and includes a
  `sync` relationship.
- A bulk sync execution resolves to a `bulk_sync_execution`, includes a
  `bulk_sync` relationship, and may include `context.schema_ids`.
- A Harbor context resolves to a `harbor_context` and includes a `harbor`
  relationship.

If the UUID does not exist, or exists outside the caller's scoped
organization, the endpoint returns `404`.

Reference: https://apidocs.polytomic.com/api-reference/entities/get

## Authentication

- `Authorization` header (bearer token, required) — Bearer user API key
- `Authorization` header (basic auth, required) — Basic organization-scoped API key

## Request

### Path parameters

- `id` (string, required) — UUID of the entity to resolve.

## Response

### 200

OK

- `data` (EntityResponse, optional)

## Errors

### 401 Unauthorized Error

Unauthorized

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

### 403 Forbidden Error

Forbidden

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

### 404 Not Found Error

Not Found

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

### 500 Internal Server Error

Internal Server Error

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

## Types

### EntityResponse

- `canonical_path` (string, optional) — Canonical REST path for the resolved resource, suitable for fetching it directly.
- `context` (map from string to any, optional) — Lightweight additional context about the resolved entity, such as bulk sync schema_ids.
- `id` (string, optional) — UUID that was resolved.
- `organization_id` (string, optional) — Organization that owns the resolved resource. Omitted from responses on the user-scoped endpoint.
- `relationships` (map from string to EntityRelationship, optional) — Parent resources needed to address nested resources, keyed by relationship name (e.g. "sync", "bulk_sync", "harbor").
- `type` (string, optional) — Resolved entity type. One of: organization, user, connection, model, model_sync, model_sync_execution, bulk_sync, bulk_sync_execution, harbor, harbor_context.

### EntityRelationship

- `id` (string, optional) — UUID of the related resource.
- `path` (string, optional) — Canonical REST path of the related resource.

## Examples

**Response**

```json
{
  "data": {
    "canonical_path": "/api/syncs/0ecd09c1-b901-4d27-9053-f0367c427254/executions/8f63fd67-5d47-4cb2-a5fc-e8b933799065",
    "context": {},
    "id": "248df4b7-aa70-47b8-a036-33ac447e668d",
    "organization_id": "248df4b7-aa70-47b8-a036-33ac447e668d",
    "relationships": {},
    "type": "model_sync_execution"
  }
}
```

**SDK Code**

```python
import requests

url = "https://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d"

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

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

print(response.json())
```

```javascript
const url = 'https://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d';
const options = {method: 'GET', headers: {Authorization: 'Bearer <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://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d"

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

	req.Header.Add("Authorization", "Bearer <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://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <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://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.polytomic.com/api/entities/248df4b7-aa70-47b8-a036-33ac447e668d")! 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()
```