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

# Getting Started with Lattice

> Turn rows of people and companies into one connected graph that resolves identities and maps the relationships between them.

Lattice turns rows of people and companies into one connected graph. Every person, email, phone, company, place, profile and IP address in your data becomes an entity, linked by relationships such as "works at" or "has email".

> [!NOTE]
>
> Lattice is in beta. It is available to Enterprise customers and is enabled on request. [Talk to sales](https://cal.com/team/sixtyfour/discovery) to turn it on for your organization.

It does two things a spreadsheet can't:

* Resolves the same person across records. An email, phone, profile URL or domain that appears in several rows becomes one entity, so those rows connect through it. Lattice merges two people when the evidence shows they are the same person, such as a shared email. When it isn't sure, it asks you under **Same entity?** instead of guessing. It never merges people on name alone.
* Maps relationships. Select any entity to see everything connected to it: who shares a phone, an employer, a city or an IP address.

## What it's built for

* Mapping connections. See everything tied to a person, company, email or phone across all your records, and who else shares it.
* Finding clusters and rings. Find groups of "different" accounts that reuse the same phone, email, address or IP address. Use it for fraud checks, duplicate cleanup and vetting.

## Before you start

* Opening and exploring a graph needs you to sign in to the [web app](https://app.sixtyfour.ai/lattice). Use a team API key to match incoming rows, look up records and manage labels programmatically. [Lattice API](https://docs.sixtyfour.ai/lattice/api.md)
* For organizations with customer-managed encryption, Lattice needs a one-time setup. Contact [support@sixtyfour.ai](mailto:support@sixtyfour.ai) to enable it.
* A graph belongs to the team that created it. It is listed only in that team, and only that team's runs can add to it.
* Graph names are unique within a team, so two teams can each have a graph with the same name. To run by API, use an API key from the graph's team.

## Build your first graph

You build graphs in [workflows](https://docs.sixtyfour.ai/guides/building-workflows.md), by adding a Lattice block to the end of a workflow.

1. Open [Workflows](https://app.sixtyfour.ai/workflows) and open a workflow that produces rows of people or companies. To start a new one, add a source such as Import Data or Search.
2. Add **Lattice**, under **Send Results**, as the last block and connect it.
3. In the block, select **Create a new graph…**, type a name, such as `software-engineers-in-sf`, and select **Create**. To add this run to a graph you already have, select that graph instead.
4. Select **Run workflow**, check the cost estimate, and start the run.
5. When the run finishes, open [Lattice](https://app.sixtyfour.ai/lattice) in the sidebar and select your graph's card.

![Lattice block at the end of a workflow](https://mintcdn.com/sixtyfour/pkXn_NFwUiVgDOO9/images/lattice-knowledge-graph-block.png?fit=max\&auto=format\&n=pkXn_NFwUiVgDOO9\&q=85\&s=35fd08c694367af21d544cc833ca6c53)

See [Credit Costs](https://docs.sixtyfour.ai/guides/credits-and-pricing.md#lattice) for what the block costs.

## Explore the graph

A graph opens in table view. Browse entities by type, search, filter and sort.

To open graph view, select any entity to see the nodes connected to it, or select **Show all** in the top right to see the whole graph.

![Graph view with the list of entities beside it](https://mintcdn.com/sixtyfour/Q-DmdzWXaUc2TwK8/images/lattice-graph-view.png?fit=max\&auto=format\&n=Q-DmdzWXaUc2TwK8\&q=85\&s=14586b2e5f9697543a7252d1bd602cfd)

Selecting a node opens its panel:

| Tab | What it shows |
| - | - |
| Node Details | The entity's properties and its timeline, such as employers and accounts. |
| Connections | Everything connected to the entity. |
| Reasoning | Why Lattice connected it. |

## Example: a shared IP address cluster

Use a graph to find accounts that look unrelated but reuse the same details. In this sample data, each row is one account. Four accounts signed up from the same IP address, `203.0.113.24`, and several of them also share a phone number. Neither pattern shows up when you read the rows one at a time.

![Accounts connected through a shared IP address and phone number](https://mintcdn.com/sixtyfour/Q-DmdzWXaUc2TwK8/images/lattice-shared-ip-cluster.png?fit=max\&auto=format\&n=Q-DmdzWXaUc2TwK8\&q=85\&s=eebf2ef69f676a790027b1ffacab7777)

## Run it by API

Build the workflow once in the web app, starting from an Import Data block, then run it by API with a new file each time: upload the file, then start a run with its `file_id`. See [Workflows](https://docs.sixtyfour.ai/api-reference/workflows/workflows-overview.md) for more on running workflows by API.

```bash cURL theme={null}
set -euo pipefail
API=https://api.sixtyfour.ai

# Upload the file
FILE_ID=$(curl --fail-with-body -sS "$API/v1/files" \
  -H "x-api-key: YOUR_API_KEY" -F "file=@people.csv;type=text/csv" | jq -r .file_id)

# Run the workflow with that file
JOB=$(curl --fail-with-body -sS "$API/v1/workflows/YOUR_WORKFLOW_ID/runs" \
  -H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
  -d "{\"source_overrides\":{\"resource_handle_id\":\"$FILE_ID\"}}")

# Poll until the Job finishes
while [ "$(echo "$JOB" | jq -r .status)" != "succeeded" ]; do
  case "$(echo "$JOB" | jq -r .status)" in failed|canceled) echo "$JOB"; exit 1;; esac
  sleep "$(echo "$JOB" | jq -r '.next_poll_after // 5')"
  JOB=$(curl --fail-with-body -sS "$API/v1/jobs/$(echo "$JOB" | jq -r .job_id)" -H "x-api-key: YOUR_API_KEY")
done
echo "$JOB" | jq -r .status
```

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

API = "https://api.sixtyfour.ai"
headers = {"x-api-key": "YOUR_API_KEY"}

with open("people.csv", "rb") as file:
    upload = requests.post(f"{API}/v1/files", headers=headers, files={"file": ("people.csv", file, "text/csv")})
upload.raise_for_status()

response = requests.post(
    f"{API}/v1/workflows/YOUR_WORKFLOW_ID/runs",
    headers=headers,
    json={"source_overrides": {"resource_handle_id": upload.json()["file_id"]}},
)
response.raise_for_status()
job = response.json()

while job["status"] not in ("succeeded", "failed", "canceled"):
    time.sleep(job.get("next_poll_after") or 5)
    response = requests.get(f"{API}/v1/jobs/{job['job_id']}", headers=headers)
    response.raise_for_status()
    job = response.json()
if job["status"] != "succeeded":
    raise RuntimeError(f"Run ended as {job['status']}")
print(job["status"])
```

```javascript JavaScript theme={null}
import { readFile } from "node:fs/promises";

const API = "https://api.sixtyfour.ai";
const headers = { "x-api-key": "YOUR_API_KEY" };

const form = new FormData();
form.append("file", new Blob([await readFile("people.csv")], { type: "text/csv" }), "people.csv");
const upload = await fetch(API + "/v1/files", { method: "POST", headers, body: form });
if (!upload.ok) throw new Error(await upload.text());
const { file_id } = await upload.json();

const started = await fetch(API + "/v1/workflows/YOUR_WORKFLOW_ID/runs", {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ source_overrides: { resource_handle_id: file_id } }),
});
if (!started.ok) throw new Error(await started.text());
let job = await started.json();

while (!["succeeded", "failed", "canceled"].includes(job.status)) {
  await new Promise((resolve) => setTimeout(resolve, (job.next_poll_after ?? 5) * 1000));
  const poll = await fetch(API + "/v1/jobs/" + job.job_id, { headers });
  if (!poll.ok) throw new Error(await poll.text());
  job = await poll.json();
}
if (job.status !== "succeeded") throw new Error("Run ended as " + job.status);
console.log(job.status);
```

Starting the run returns a Job. Poll it with its `job_id`:

```json HTTP 202 theme={null}
{
  "job_id": "job_3f8b2c1e-9d4a-4c1b-8e2f-6a7b5c4d3e21",
  "status": "running",
  "created_at": "2026-11-13T10:00:00Z",
  "next_poll_after": 5,
  "operation": "workflows.run",
  "charge_credits": 0.0
}
```

A Job ends as `succeeded`, `failed` or `canceled`. [Workflow Execution](https://docs.sixtyfour.ai/api-reference/workflows/workflows-execution.md#check-a-run) describes every Job field.

## Questions and feedback

Email [support@sixtyfour.ai](mailto:support@sixtyfour.ai) with questions or feedback.


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