---
title: "Connect JustSift to Claude: Advanced People Search and Media Access"
slug: connect-justsift-to-claude-advanced-people-search-and-media-access
date: 2026-10-07
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect JustSift to Claude. Automate people searches, dynamic profile discovery, and media extraction."
tldr: "A complete technical guide to connecting JustSift to Claude via Model Context Protocol (MCP). We cover handling dynamic organizational schemas, complex search logic, and zero-data-retention security."
canonical: https://truto.one/blog/connect-justsift-to-claude-advanced-people-search-and-media-access/
---

# Connect JustSift to Claude: Advanced People Search and Media Access

**JustSift in Claude, in about a minute.** The best way to connect JustSift to Claude is Elaichi: connect JustSift to Elaichi once, then add Elaichi to Claude as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect JustSift.** Connect JustSift once in Elaichi. Claude never gets more access than you have.
3. **Add Elaichi to Claude.** In Claude, open Customize, then Connectors, press Add and paste https://api.elaichi.ai/mcp. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=justsift) · [JustSift on Elaichi](https://elaichi.ai/connectors/justsift/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=justsift)

*Building JustSift into your own product? The guide below is for you.*

---

If your engineering or IT teams need to connect JustSift to Claude to automate people searches, extract employee media, or map organizational structures, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calling capabilities and JustSift's REST API. You can either [build, host, and maintain this infrastructure yourself](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL.

If your team uses ChatGPT, check out our guide on [/connect-justsift-to-chatgpt-search-people-and-explore-profiles/](https://truto.one/connect-justsift-to-chatgpt-search-people-and-explore-profiles/). If you are building headless applications with autonomous systems, explore our broader architectural overview on [/connect-justsift-to-ai-agents-query-people-and-dynamic-profile-data/](https://truto.one/connect-justsift-to-ai-agents-query-people-and-dynamic-profile-data/).

Giving a Large Language Model (LLM) read and write access to an enterprise people directory like JustSift introduces specific technical hurdles. You have to handle API authentication lifecycles, map dynamic JSON schemas to MCP tool definitions, and deal with complex search query structures. Every time JustSift updates an endpoint or an administrator adds a new custom attribute to your directory, a hardcoded custom integration will fail. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for JustSift, connect it natively to Claude, and execute complex data extraction workflows using natural language.

> Want to give your AI agents secure, authenticated access to JustSift and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the JustSift API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover and execute tools using JSON-RPC 2.0, the reality of implementing it against a highly configurable B2B API like JustSift is painful. 

If you decide to [build a custom JustSift MCP server from scratch](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), you own the entire integration lifecycle. Here are the specific challenges you will face with the JustSift API:

**Dynamic Per-Organization Schemas**
JustSift does not enforce a rigid, universal schema for person profiles. Instead, a person record contains a mix of standard properties and dynamic, per-organization fields. An LLM has no inherent context on what fields exist in your specific JustSift tenant. If you hardcode a tool that searches for `department`, it will fail if your organization's administrators decided to use the key `cost_center_dept`. You must build an abstraction layer that allows the model to introspect the available fields dynamically before constructing its queries.

**Complex Nested Search Logic**
Querying people in an enterprise directory is rarely as simple as `?name=John`. JustSift's complex search endpoint requires deep JSON payloads supporting nested `AND` and `OR` boolean operators against specific field keys. Manually maintaining JSON Schema definitions for these complex payloads so an LLM can understand them requires constant upkeep. If the schema mapping is flawed, Claude will hallucinate query parameters, resulting in HTTP 400 Bad Request errors.

**Binary Media Handling**
Extracting employee photos from JustSift involves handling binary JPEG image data. Passing raw binary streams back through the text-based MCP protocol requires proper encoding and formatting. Custom bridges often crash when they fail to correctly serialize binary buffers into base64 or valid file transport objects.

## Generating the Managed JustSift MCP Server

Truto solves these problems by reading the JustSift API documentation and [dynamically generating perfectly typed MCP tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) on the fly. Each MCP server is scoped to a single integrated account (a connected instance of JustSift for a specific tenant) and authenticated via a secure cryptographic token.

You can generate your JustSift MCP server using either the Truto Dashboard or the REST API.

### Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the server directly from your Truto dashboard:

1. Navigate to the **Integrated Accounts** page for your JustSift connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (name, allowed methods, tags, and optional expiration).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For teams automating infrastructure or provisioning agents programmatically, you can create the MCP server via a simple POST request. This endpoint validates the configuration, generates a secure token stored in Cloudflare KV, and returns the connection URL.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude JustSift Access",
    "config": {
      "methods": ["read"]
    }
  }'
```

The API returns a ready-to-use URL:

```json
{
  "id": "abc-123",
  "name": "Claude JustSift Access",
  "config": { "methods": ["read"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to Claude. Because Truto handles the OAuth token lifecycle and JustSift schema mapping internally, the client requires zero additional configuration beyond the URL.

### Method A: Via the Claude UI

If you are using Claude's web or desktop interface with custom connector support:

1. Open Claude and navigate to **Settings**.
2. Select **Integrations** or **Connectors** (depending on your specific Claude tier).
3. Click **Add MCP Server**.
4. Paste the Truto MCP server URL you generated earlier.
5. Click **Add**. Claude will immediately execute an MCP `initialize` handshake, discover the JustSift tools, and make them available in your chat context.

### Method B: Via Manual Config File (Claude Desktop)

If you are running Claude Desktop and prefer file-based configuration, you can use the official Server-Sent Events (SSE) transport adapter.

Open your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add the following:

```json
{
  "mcpServers": {
    "justsift-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```

Restart Claude Desktop. The application will spawn the SSE transport bridge and connect to your JustSift instance.

## JustSift Hero Tools for Claude

Truto automatically derives tools from JustSift's resources and documentation records. When Claude requests the available tools via the `tools/list` JSON-RPC method, Truto dynamically generates the definitions - including required parameters and strict JSON schemas.

Here are the high-leverage hero tools available for the JustSift integration.

### 1. list_all_just_sift_person_fields

Because JustSift uses dynamic per-organization attributes, this tool is the mandatory first step for any complex query. It lists the person profile fields configured in your specific JustSift tenant, returning definitions including the `objectKey` and whether the field is `searchable`.

**Usage note:** Always instruct Claude to call this tool before attempting to filter by custom attributes like department, location, or job title.

> "I need to find all engineers in London. Before you search, list the available person fields in JustSift so we know the correct object keys for 'job title' and 'location'."

### 2. list_all_just_sift_complex_search_people

This is the most powerful search operation available. It allows Claude to search JustSift people using complex `AND`/`OR` filter logic against specific person fields, combined with optional generic text queries and field-based sorting. It returns arrays containing the `id` and `email` of matching records.

**Usage note:** Claude must use the exact `objectKey` values discovered via the fields tool to construct the boolean filter array.

> "Using the complex search tool, find all people where the department is exactly 'Engineering' AND the location is 'New York'. Sort the results by last name in ascending order."

### 3. list_all_just_sift_search_people

For broader queries, this tool performs a simple people search. It returns a collection of matching people including their `id`, `firstName`, `lastName`, `pictureUrl`, and their dynamic per-organization fields. It accepts a general `q` string plus optional exact-match field filters.

**Usage note:** By default, exact-match filters combine with `AND`. You can instruct Claude to set `orQuery` to `true` to change the behavior.

> "Do a simple search for anyone named 'Sarah' who works in the Marketing department. Return their full names and employee IDs."

### 4. get_single_just_sift_person_by_id

Once Claude identifies a specific user, this tool retrieves the complete person record. You can query by either the internal JustSift `id` or the user's `email address`. The response includes all standard properties and populated dynamic fields.

**Usage note:** This is typically chained after a search operation to get deep context on a single individual.

> "Get the full profile details for the employee with the email 'sarah.connor@example.com'. Summarize her current role, manager, and start date based on the custom fields in the response."

### 5. list_all_just_sift_people_media

This tool retrieves a person's photo from JustSift by their `id` or `email`. It handles the binary JPEG image data, allowing Claude to extract media assets for reporting, org charts, or external syncing.

**Usage note:** You must provide the `media_kind` parameter to specify which asset type to pull.

> "Fetch the profile photo media data for employee ID 847593. Ensure you specify the correct media_kind parameter for their primary portrait."

For the complete inventory of available JustSift tools and their exact JSON Schema definitions, visit the [JustSift integration page](https://truto.one/integrations/detail/justsift).

## Workflows in Action

Giving Claude raw API tools is only half the battle. The real value comes from chaining these tools together to execute complex workflows. Here is how Claude orchestrates multi-step JustSift operations.

### Scenario 1: Org Chart Discovery and Mapping

An IT administrator needs to audit the reporting structure of a specific remote office. They do not know the exact field names JustSift uses internally for locations or managers.

> "I need a list of everyone working in our 'Austin' office, and I need to know who they report to. Figure out what fields JustSift uses for location and managers, run the search, and build me a text-based org chart for that office."

1. Claude calls `list_all_just_sift_person_fields` to map the schema. It discovers that location is stored under `custom_loc_id` and the manager is under `reports_to_email`.
2. Claude formulates a boolean query and calls `list_all_just_sift_complex_search_people` with a filter on `custom_loc_id = Austin`.
3. JustSift returns a list of IDs. Claude iterates through them, calling `get_single_just_sift_person_by_id` for each ID to extract the `reports_to_email` value.
4. Claude processes the raw JSON and outputs a formatted, hierarchical org chart for the user in the chat interface.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant JustSift as JustSift API

    User->>Claude: "Map the Austin office org chart"
    Claude->>Truto: Call list_all_just_sift_person_fields
    Truto->>JustSift: GET /fields/person
    JustSift-->>Truto: Return schema
    Truto-->>Claude: Schema (loc=custom_loc_id)
    Claude->>Truto: Call list_all_just_sift_complex_search_people
    Truto->>JustSift: POST /search/complex
    JustSift-->>Truto: Return user IDs
    Truto-->>Claude: User IDs
    Claude->>Truto: Call get_single_just_sift_person_by_id (loop)
    Truto->>JustSift: GET /person/{id}
    JustSift-->>Truto: Return full profiles
    Truto-->>Claude: Profile data
    Claude-->>User: Formatted Org Chart Output
```

### Scenario 2: Profile Enrichment and Audit

A security engineer is cross-referencing departing employees and needs to extract their profile data and ID badges.

> "We have an employee leaving today named Marcus Thorne. Find his profile, list all the internal system access tags on his account, and extract his profile photo so I can attach it to the offboarding ticket."

1. Claude calls `list_all_just_sift_search_people` with the query `q="Marcus Thorne"`.
2. JustSift returns his profile summary, including his ID `99421`.
3. Claude calls `get_single_just_sift_person_by_id` using ID `99421` to pull the deep profile attributes, scanning for security and system access tags.
4. Claude calls `list_all_just_sift_people_media` with ID `99421` to extract the binary photo data.
5. Claude presents the security tags as a bulleted list and confirms the photo data has been retrieved successfully.

## Security and Access Control

Connecting an LLM to an enterprise directory requires strict governance. Truto MCP servers are self-contained and enforce security at the infrastructure level.

*   **Method Filtering:** You can restrict your JustSift MCP server to read-only operations. By passing `config: { methods: ["read"] }` during creation, Truto ensures `create`, `update`, and `delete` tools are never generated or exposed to Claude.
*   **Tag Filtering:** Limit the server surface area to specific functional domains. If you only want Claude to access media endpoints, you can apply tag filters during server creation.
*   **Expiration (TTL):** For temporary access (e.g., contractor workflows or audits), you can set an `expires_at` ISO datetime. Truto schedules a Durable Object alarm to automatically permanently delete the token and KV entries at that exact moment.
*   **Dual Authentication:** By default, the cryptographically hashed MCP URL is the only auth required. For zero-trust environments, setting `require_api_token_auth: true` forces Claude to also pass a valid Truto API token in the `Authorization` header, adding a second layer of verification.
*   **Rate Limits and Quotas:** Factual note on rate limits - Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream JustSift API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (your agent framework or Claude client) is responsible for implementing retry and backoff logic.

## Escaping the Integration Maintenance Trap

Building a custom integration between Claude and JustSift means you are signing up to maintain undocumented API quirks, schema drift, and pagination logic forever. 

By leveraging Truto's dynamically generated MCP servers, you offload the infrastructure burden. Truto translates JustSift's complex dynamic field models into strictly typed JSON-RPC tools that Claude inherently understands. You get immediate, secure AI access to your people data without writing a single line of integration code.

> Ready to connect Claude to JustSift? Let's discuss how managed MCP architecture can accelerate your AI engineering.
>
> [Talk to us](https://truto.one/book-a-demo/)