Connect JustSift to ChatGPT: Search People and Explore Profiles

If you need to connect JustSift to ChatGPT to automate people search workflows, audit employee profiles, or extract dynamic organizational data, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between ChatGPT's JSON-RPC tool calls and JustSift's REST APIs. You can either spend weeks building and maintaining this custom integration infrastructure, or use a managed platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds.

If your team uses Claude, check out our guide on connecting JustSift to Claude or explore our broader architectural overview on connecting JustSift to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise directory and search platform is an engineering challenge. You have to handle complex search payloads, map dynamic profile schemas to MCP tool definitions, and deal with binary media files like profile photos. Every time an organization adds a new custom attribute to their JustSift instance, your custom server code must be updated, redeployed, and tested to prevent the LLM from hallucinating field names.

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

The Engineering Reality of the JustSift API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against JustSift's specific architecture requires managing several unique constraints.

If you build a custom MCP server for JustSift, you own the entire API lifecycle. Here are the specific integration challenges you will face:

Dynamic Per-Organization Profile Schemas

Unlike standard SaaS applications with fixed JSON objects, JustSift allows organizations to heavily customize person profiles. An LLM querying for a user might receive standard fields (firstName, email), alongside completely arbitrary objectKey fields like department_cost_center_id or remote_work_eligibility. A static MCP server cannot parse this reliably. Your integration layer must query the field configuration dynamically and inject those definitions into the LLM's context so it knows which keys are valid for filtering and updating. Without this, the model will invent properties.

Complex AND/OR Search Logic Payloads

JustSift's advanced search capabilities require deeply nested JSON payloads to execute complex AND/OR logic. Translating a user prompt like "Find everyone in Marketing who is remote, OR anyone in Sales with a manager title" into JustSift's specific query syntax requires rigorous schema validation. If your MCP server does not enforce strict query_schema boundaries, the LLM will construct invalid nested arrays, resulting in HTTP 400 errors from JustSift.

Handling Binary Media Data

JustSift serves profile pictures as binary JPEG image data via its media endpoints. LLMs operate strictly via text and JSON. If an agent tries to fetch a user's photo to verify their identity, a custom MCP server must intercept the binary stream, convert it into an MCP-compatible format (like base64 text), or manage a signed URL system. Passing raw binary data directly back through a JSON-RPC response will crash the client.

JustSift to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT successfully calling the JustSift API, follow these steps.

What you need:

• A Truto account with API access.
• A JustSift admin account for authentication.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode enabled.

Step 1: Connect JustSift as an Integrated Account

In the Truto dashboard, open Integrated Accounts -> New Integrated Account, select JustSift, and complete the authentication flow. Truto will securely store the credentials and handle all future token refreshes automatically. ChatGPT will never interact with an expired session.

Step 2: Grab your Integrated Account ID

You can copy your integrated_account_id directly from the account detail page in the UI, or list your accounts via the API:

curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 3: Generate a JustSift MCP Server

Truto creates an isolated, secure MCP endpoint scoped strictly to that specific JustSift account. You can do this via the UI or the API.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your JustSift connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., read-only methods).
5. Copy the generated MCP server URL.

Method B: Via the API Execute a single POST request to generate the server. We will filter by methods to restrict ChatGPT to read-only search queries.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "JustSift Search for ChatGPT",
    "config": {
      "methods": ["read"]
    }
  }'

Truto returns a payload containing a url field (e.g., https://api.truto.one/mcp/<token>). This URL contains a hashed cryptographic token that handles all routing and authentication - treat it like a secret.

Step 4: Register the Server in ChatGPT

With your MCP URL ready, you need to configure ChatGPT to use it as a custom tool connector.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "JustSift (Truto)") and paste your MCP server URL.
5. Save the configuration. ChatGPT will immediately connect and discover the available JustSift tools.

Method B: Via manual config file If you are managing an external agent framework or desktop client that uses SSE (Server-Sent Events) for remote MCP servers, you can register it via a JSON configuration:

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

flowchart TD
    A["ChatGPT Client<br>(JSON-RPC 2.0)"] -->|"POST /mcp/:token"| B["Truto MCP Router"]
    B -->|"Hash Token & Validate"| C["Global Edge Store"]
    B -->|"Fetch Docs & Schemas"| D["Tool Generation Engine"]
    D -->|"Proxy API Execution"| E["JustSift API"]
    
    classDef default fill:#f9f9f9,stroke:#333,stroke-width:1px;

Hero Tools for JustSift

Truto automatically generates MCP tool definitions directly from the JustSift API documentation. Tools are heavily typed and derived from the underlying resource schemas. Here are the highest-leverage tools ChatGPT will use to interact with JustSift.

list_all_just_sift_complex_search_people

This tool executes deep, conditional queries against the JustSift directory using complex AND/OR filter logic. It accepts an optional generic text query alongside field-based sorting, returning high-level identifiers (id, email) with a strict maximum of 100 results per page.

"Find all employees in the engineering department who are marked as senior engineers, OR anyone with 'architect' in their job title. Sort the results alphabetically by last name."

get_single_just_sift_person_by_id

Fetches a comprehensive single profile record using the person's unique ID or email address. This is critical for retrieving the dynamic, per-organization profile attributes that are not exposed in high-level search collections.

"Get the full profile details for the employee with the email address j.smith@acmecorp.com so I can verify their current cost center and reporting line."

list_all_just_sift_search_people

Provides a streamlined, simple search mechanism for broad directory queries. It returns a collection of matching profiles including id, firstName, lastName, and pictureUrl. It accepts exact-match field filters (e.g., department=Marketing) which default to AND logic unless orQuery is explicitly set to true.

"Run a simple search for anyone named 'Sarah' who works in the 'Marketing' department and give me their profile picture URLs."

list_all_just_sift_people_media

Retrieves binary media files linked to a user profile, specifically their profile photo. It requires the user's ID or email and the media_kind. Truto manages the protocol translation to ensure the binary JPEG stream is cleanly represented to the MCP client.

"Fetch the profile photo for the user ID 847291. I need to verify their image matches the new ID badge requirements."

list_all_just_sift_person_fields

This is the most critical metadata tool. It lists all active person profile fields configured within that specific JustSift organization. It returns definitions detailing the objectKey and whether the field is searchable. The LLM must call this before constructing advanced queries to ensure it uses valid field names.

"List all the custom person fields configured for this organization so I know what attributes I can use to filter the directory for remote employees."

For a complete list of endpoints, pagination methods, and schema definitions, view the full JustSift integration page.

Workflows in Action

Once connected, ChatGPT can orchestrate multi-step data extractions that normally require custom scripts. Here is how specific personas use these tools in reality.

Scenario 1: HR Admin auditing employee profiles

A Human Resources administrator needs to audit the directory to ensure all managers have a specific custom compliance tag applied to their profiles.

"First, list all the custom profile fields available in JustSift so we know the exact name of the compliance tag. Then, run a complex search for everyone with 'Manager' or 'Director' in their title. Finally, retrieve their full profiles and tell me who is missing the compliance tag."

Execution flow:

1. list_all_just_sift_person_fields: ChatGPT pulls the dynamic schema to discover the exact objectKey for the compliance tag (e.g., 2026_compliance_certified).
2. list_all_just_sift_complex_search_people: Constructs an OR payload targeting job titles to extract a list of manager IDs.
3. get_single_just_sift_person_by_id: Loops through the returned IDs to pull the full attribute payload, isolating those where 2026_compliance_certified is null or false.

Scenario 2: IT Manager resolving missing department field tags

An IT administrator needs to build a contact list for an internal email migration, but needs to find everyone who lacks a clear department assignment.

"Run a simple search to find all employees where the department field is empty or missing. Give me their names, emails, and fetch their profile photos so I can manually identify them against our legacy system."

Execution flow:

1. list_all_just_sift_search_people: Executes a targeted query filtering for null department objects, returning the IDs and basic metadata.
2. list_all_just_sift_people_media: Uses the returned IDs to fetch the binary JPEG data for each orphaned profile, providing the IT manager with visual context to resolve the missing data.

sequenceDiagram
    autonumber
    participant User as ChatGPT
    participant Truto as Truto MCP
    participant API as JustSift API
    
    User->>Truto: list_all_just_sift_person_fields()
    Truto->>API: GET /fields/person
    API-->>Truto: Return dynamic field schema
    Truto-->>User: Schema details (JSON-RPC)
    
    User->>Truto: list_all_just_sift_complex_search_people(payload)
    Truto->>API: POST /search/complex
    API-->>Truto: Return matched IDs
    Truto-->>User: Search results (JSON-RPC)

Security and Access Control

Giving an AI agent access to an enterprise directory is a massive security risk if not heavily constrained. Truto provides four distinct mechanisms to lock down your MCP servers:

• Method Filtering (config.methods): Restrict the server to safe HTTP operations. Setting this to ["read"] ensures ChatGPT can only query JustSift and absolutely cannot create, update, or delete profile records.
• Tag Filtering (config.tags): Integration endpoints are tagged by functional area. You can restrict the MCP server to only expose tools tagged with search, hiding sensitive administrative endpoints.
• Extra Authentication (require_api_token_auth): When enabled, possessing the MCP URL is not enough. The client must also pass a valid Truto API token in the Authorization header, preventing unauthorized access if the URL leaks.
• Automatic Expiration (expires_at): Generate short-lived MCP servers with strict ISO datetime expirations. Perfect for temporary audits, the server and its authentication automatically self-destruct when the deadline is reached.

Handling Rate Limits in Production

When scaling automated AI workflows, you will inevitably hit API rate limits. It is critical to understand that Truto operates as a transparent proxy. Truto does not retry, throttle, or apply backoff on rate limit errors.

When the JustSift API returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the caller. However, Truto heavily normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (or the agent framework executing the tool) is fully responsible for intercepting the 429 error, reading the ratelimit-reset header, and applying appropriate exponential backoff or retry logic.

Moving Past Manual Integration

Connecting an LLM to JustSift's dynamic schemas and complex search endpoints manually means writing hundreds of lines of fragile parsing logic. By using Truto's managed MCP servers, you offload the authentication lifecycle, schema validation, and tool derivation entirely.

You generate a single secure URL, paste it into ChatGPT, and instantly give your AI agents the ability to search, filter, and audit complex organizational directories using natural language.