# Ploid

```json
{
  "name": "Ploid",
  "slug": "ploid",
  "url": "https://composio.dev/toolkits/ploid",
  "markdown_url": "https://composio.dev/toolkits/ploid.md",
  "logo_url": "https://logos.composio.dev/api/ploid",
  "categories": [
    "sales & customer support"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-10-31T05:36:40.814Z"
}
```

![Ploid logo](https://logos.composio.dev/api/ploid)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Ploid MCP or direct API to research people, enrich identities, analyze public LinkedIn intelligence, and gather agent-powered insights through natural language.

## Summary

Ploid is a people research and identity intelligence platform with public LinkedIn data and research APIs.
It helps teams enrich identities and uncover useful professional insights quickly.

## Categories

- sales & customer support

## Toolkit Details

- Tools: 42

## Images

- Logo: https://logos.composio.dev/api/ploid

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Ploid.
  - Setup:
    - Configure Api Key credentials for Ploid.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Research prospects and enrich their identities
- Find public LinkedIn intelligence on prospects
- Build a people research brief

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `PLOID_cancel_person_run` | Cancel Person Run | Irreversibly cancel an active deep-person research run. Cancellation is uncharged and prevents the run from completing. |
| `PLOID_cancel_set` | Cancel People Set | DESTRUCTIVE: irreversibly stop the active search for a preview People Set. People already admitted remain in the Set and are still billed at 1 ACU per 10 admitted people, rounded up when cancellation settles. The preview request and response contracts may change before general availability. Verify the Set ID before calling, supply an Idempotency-Key for safe identical retries, and never live-test this action without a disposable Set. |
| `PLOID_compile_monitor` | Compile Monitor | Preview a social-monitor plan, resolved targets, relevance rules, and output schema without creating a monitor or scheduling runs. A completed compile costs exactly 1 ACU. Ploid requires authentication but does not publicly document the monitor permission scope. |
| `PLOID_create_dataset` | Create Dataset | Create a persistent typed dataset and fill 1-30 columns for seeded people, companies, or custom entities. Sync supports up to 25 rows; async supports 2,000 and continues processing and billing after this call returns. Ploid reserves the all-found maximum against the API-key budget, then bills only found cells: standard built-ins cost 1 ACU per 10, custom and work-email cells 1 each, personal email 3 each, and phone 10 each. Not-found, unverified, and timeout cells are free. A failed sync fill can still persist and bill completed cells; recover them with the dataset_id in the error. |
| `PLOID_create_monitor` | Create Monitor | Create a persistent scheduled social monitor and immediately start a silent baseline run. Creation and compilation cost 1 ACU. Each later run costs 1 ACU per target fetched plus 1 ACU per emitted item. Supply an Idempotency-Key and reuse it with identical input when retrying an uncertain result. Webhook configuration is intentionally unavailable in this action. |
| `PLOID_create_set` | Create People Set | Create a persistent preview People Set and start durable verified background work that may continue after this call returns. The preview request and response contracts may change before general availability. Ploid checks available balance and reserves the requested count's estimated charge against API-key daily and monthly budgets, then settles at 1 ACU per 10 admitted people, rounded up; people admitted before failure or cancellation remain billed. Supply an Idempotency-Key and reuse it only for an identical retry so creation and billing replay once. |
| `PLOID_delete_monitor` | Delete Monitor | Destructively and irreversibly disable a monitor. It will no longer run on its schedule; verify the monitor ID before calling. No charge is documented. Ploid requires a monitor permission but does not document its name. |
| `PLOID_enrich_person_contact` | Enrich Person Contact | Resolve requested work email, personal email, and/or phone fields for one person. Identify the person with exactly one of linkedin_url, person_id, email, or name together with company_domain. Only found fields are billed; clean misses and provider failures are free. Per-field prices are not published. Partial responses preserve each field's status and provide retry guidance in warnings and Retry-After. |
| `PLOID_enrich_social_profile` | Enrich Social Profile | Resolve one public social profile from a supported platform handle, vanity slug, or profile URL. Successful enrichment is billed at a platform-specific amount that is not fully published; profile-not-found and provider failures are free. |
| `PLOID_export_set` | Export People Set | Export admitted items from a preview People Set. CSV is the default and returns a downloadable file; JSON returns the provider's raw item values. No export charge is documented. The preview Sets API is absent from Ploid's OpenAPI document and its response contract may change before general availability. |
| `PLOID_get_account_credits` | Get Account Credits | Return the workspace ACU balance and the calling API key's daily and monthly spending-budget state. This read-only request has no documented charge. |
| `PLOID_get_account_profile` | Get Account Profile | Return the signed-in user's WorkOS-linked Ploid account profile. This is a read-only operation, and no charge is documented. |
| `PLOID_get_account_usage` | Get Account Usage | Preferred connection diagnostic for verifying which Ploid workspace and API key are connected. Returns workspace ACU usage, the calling key's ID and budget, and the number of active keys. No charge is documented. |
| `PLOID_get_dataset` | Get Dataset | Return a dataset's lifecycle status, configured columns, row-processing progress, and rows URL. No read charge is documented. |
| `PLOID_get_linkedin_company` | Get LinkedIn Company | Fetch public LinkedIn company details by URL, universal name, or search term; provide at least one of those locators. This read can consume ACU, but Ploid does not publish a fixed amount. |
| `PLOID_get_linkedin_profile` | Get LinkedIn Profile | Fetch one public LinkedIn profile by full URL, vanity slug, or @handle. Warning: this read can consume ACU, but Ploid does not publish a fixed per-call cost; workspace balance and API-key budget checks apply. |
| `PLOID_get_monitor` | Get Monitor | Return one monitor and its current configuration. No read charge is documented. Ploid requires a monitor permission but does not document its name. |
| `PLOID_get_monitor_run` | Get Monitor Run | Return one monitor run by monitor and run ID, including lifecycle state, usage, error, and webhook delivery outcome. No read charge is documented. Ploid requires monitor permission but does not publicly name its scope. |
| `PLOID_get_person` | Get Person | Get an evidence-backed reviewed person record or start a durable research run. The first successful organization-wide profile access costs exactly 25 ACU, including a first access served from cache; rereads are free for 90 days, and failed, unsure, or not-found runs are free. A 202 response is only a run handle: poll it with Get Person Run rather than repeating this POST. Stale cached results can queue a background refresh. |
| `PLOID_get_person_run` | Get Person Run | Get the current state or terminal result of a deep-person research run. Polling has no separate charge; the originating successful profile may cost 25 ACU. |
| `PLOID_get_set` | Get People Set | Return a preview People Set's status, progress, and searches, newest first. No read charge is documented. This preview API is absent from Ploid's OpenAPI document and its response contract may change before general availability. |
| `PLOID_list_company_recruiters` | List Company Recruiters | Return recruiters and role counts for up to 10 companies. Ploid bills unique non-placeholder companies for returned matches, but the exact ACU amount is not published. |
| `PLOID_list_dataset_rows` | List Dataset Rows | Return one integer-cursor page of dataset rows in seed order, including rows available before asynchronous processing finishes. No read charge is documented. |
| `PLOID_list_linkedin_company_posts` | List LinkedIn Company Posts | Return one provider page of posts for a LinkedIn company. The fixed cost is unknown. Use company, company_id, or company_universal_name to select a company when needed. Optional posted_limit and scrape_posted_limit opaque provider selectors are available for values documented by Ploid or previously known to work. Supply page and pagination_token manually because the response location of the next token is undocumented. |
| `PLOID_list_linkedin_posts` | List LinkedIn Posts | Return up to 20 recent posts for one public LinkedIn profile identified by profile URL, vanity slug, or @handle; provide identifier or its url alias. This read can consume ACU, but Ploid does not publish a fixed cost. |
| `PLOID_list_linkedin_profile_comments` | List LinkedIn Profile Comments | Return one provider page of comments made by a LinkedIn profile. This read can consume ACU, but Ploid does not publish a fixed amount. Use profile or profile_id to select a profile when needed. The optional posted_limit opaque provider selector is available for a value documented by Ploid or previously known to work. Supply page and pagination_token manually because the response location of the next token is undocumented. |
| `PLOID_list_monitor_items` | List Monitor Items | Return one cursor-controlled page of emitted monitor items, optionally limited to one run. No read charge is documented. Ploid requires a monitor permission but does not document its name. |
| `PLOID_list_monitor_runs` | List Monitor Runs | Return one cursor-controlled page of a monitor's runs, newest first. No read charge is documented. Ploid requires a monitor permission but does not document its name. |
| `PLOID_list_monitors` | List Monitors | Return one cursor-controlled page of monitors, newest first. No read charge is documented. Ploid requires monitor permission but does not publicly name the required scope. |
| `PLOID_list_set_items` | List People Set Items | Return one caller-controlled page of admitted, criterion-verified people while or after a preview People Set runs. Reading does not have a documented charge; billing belongs to the originating search and settles at 1 ACU per 10 admitted people, rounded up. Follow data.next_cursor for the next page; the preview API may add further response metadata before general availability. |
| `PLOID_list_sets` | List People Sets | List the workspace's recent People Sets. This API is in preview: Ploid documents the response as data.sets and does not document item fields or pagination controls. No read charge is documented. |
| `PLOID_resolve_person` | Resolve Person | Resolve a named person plus at least one identity clue to a permanent Ploid person ID. A found match costs 2 ACU; no match is free. Reusing an idempotency key is safe only for an identical authenticated retry. |
| `PLOID_run_monitor` | Run Monitor | Queue a persistent monitor run now. It costs 1 ACU per target fetched plus 1 ACU per emitted item, saves emitted items, and may deliver events to the monitor's configured webhook. The run continues after the 202 response. Poll the returned run instead of repeating this POST. Supply an Idempotency-Key and reuse it with identical input for an uncertain retry. The required monitor permission name is undocumented. |
| `PLOID_search_github_accounts` | Search GitHub Accounts | Search Ploid's GitHub account index by profile, repository, language, and activity filters. Provide at least one account search criterion. Each completed search costs 1 ACU; include_profiles adds 1 ACU per live profile found. Failed searches are free. |
| `PLOID_search_github_people` | Search GitHub People | Search GitHub accounts, link unambiguous accounts to indexed LinkedIn people, and enforce optional LinkedIn filters as hard requirements. Provide at least one GitHub search criterion. Costs 1 ACU per completed search plus 1 ACU per returned person; failed searches are free. Pages advance over GitHub accounts scanned, so returned results can be fewer than the page limit; continue with data.next_offset. |
| `PLOID_search_linkedin_people` | Search LinkedIn People | Return one cursor-controlled page of public LinkedIn people matching structured keyword, location, title, current-company, and school filters. This search can consume ACU or API-key budget, but Ploid does not publish a fixed cost. |
| `PLOID_search_people` | Search People | Search for up to 150 people and return typed results inline. Pricing varies by search mode and returned results. Use Create People Set for durable background searches. |
| `PLOID_search_people_candidates` | Search People Candidates | Search the indexed people directory for up to 10 unverified identity candidates. Costs exactly 1 ACU for every completed search, including zero matches; failures are free. Does not research or enrich profiles. |
| `PLOID_test_monitor` | Test Monitor | Fetch and evaluate a monitor's current targets without saving a run, items, seen-ledger entries, or snapshots; sending a webhook; or changing its schedule. Each call costs exactly 1 ACU per target fetched, including targets that yield no relevant items. Ploid does not document the required monitor permission name. |
| `PLOID_test_monitor_webhook` | Test Monitor Webhook | Immediately send one signed monitor.webhook.test event to the monitor's configured external webhook. This causes external network delivery as soon as the action runs. Ploid makes one delivery attempt with no retries, and this operation costs no ACU. Supply an Idempotency-Key and reuse it with identical input after an uncertain result to avoid duplicate delivery. Ploid requires a monitor permission but does not document its name. |
| `PLOID_update_account_profile` | Update Account Profile | REAL ACCOUNT MUTATION: replace the signed-in user's WorkOS-linked Ploid profile fields. Every field is required; null clears a profile URL. No charge is documented. NEVER TEST OR CALL THIS ACTION against a real account; use it only with an explicitly authorized disposable account. |
| `PLOID_update_monitor` | Update Monitor | Update, pause, or resume a monitor by providing at least one field to change. This mutates its durable configuration; query or plan changes start a new baseline run and may lead to later scheduled work. No fixed update charge is documented, but baseline work can consume ACU or API-key budget. Webhook configuration is intentionally unavailable in this action. Ploid does not document the monitor permission name. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
```python
pip install composio composio_openai openai
```

```typescript
npm install @composio/core @composio/openai openai
```

#### Path 1, Step 2: Create a Composio session

Initialize Composio with the OpenAI Responses provider and create a session scoped to Ploid
```python
import json
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
client = OpenAI()

session = composio.create(user_id="your-user-id", toolkits=["ploid"])
tools = session.tools()
```

```typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["ploid"] });
const tools = await session.tools();
```

#### Path 1, Step 3: Run Ploid tools with your agent

Send a request, execute the Ploid tool calls through the session, and print the final answer
```python
response = client.responses.create(
    model="gpt-5.6-sol",
    tools=tools,
    input=[{"role": "user", "content": "Research Jane Smith, the VP of Sales at Acme, using public LinkedIn intelligence and summarize her current role, location, and professional background."}],
)

while True:
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        break
    results = composio.provider.handle_tool_calls(response=response, session=session)
    response = client.responses.create(
        model="gpt-5.6-sol",
        tools=tools,
        previous_response_id=response.id,
        input=[
            {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(results[i])}
            for i, call in enumerate(tool_calls)
        ],
    )

print(response.output_text)
```

```typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "Research Jane Smith, the VP of Sales at Acme, using public LinkedIn intelligence and summarize her current role, location, and professional background." }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and your agent framework
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
```

#### Path 2, Step 2: Create a session with MCP enabled

Create a session scoped to Ploid and read its MCP URL and headers
```python
from composio import Composio

composio = Composio()
session = composio.create(user_id="your-user-id", toolkits=["ploid"], mcp=True)
```

```typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["ploid"],
  mcp: true,
});
```

#### Path 2, Step 3: Connect your agent to the MCP server

Pass the session's MCP URL and headers to your agent and run a Ploid request
```python
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AssistantMessage, TextBlock

options = ClaudeAgentOptions(
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": session.mcp.headers,
        }
    },
    system_prompt="You are a helpful assistant with access to Ploid tools.",
    tools=[],
    allowed_tools=["mcp__composio__*"],
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query("Research Jane Smith, the VP of Sales at Acme, using public LinkedIn intelligence and summarize her current role, location, and professional background.")
        async for message in client.receive_response():
            if isinstance(message, AssistantMessage):
                for block in message.content:
                    if isinstance(block, TextBlock):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "Research Jane Smith, the VP of Sales at Acme, using public LinkedIn intelligence and summarize her current role, location, and professional background.",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
```

## Why Use Composio?

### 1. AI Native Ploid Integration

- Supports both Ploid MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable people research and identity enrichment
- Rich coverage for querying public LinkedIn intelligence and research data

### 2. Managed Auth

- Securely stores and applies your Ploid API key to tool requests
- Central place to manage, scope, and revoke Ploid access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve research reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Ploid
- Scoped, least privilege access to Ploid research resources
- Full audit trail of agent actions to support review and compliance

## Use Ploid with any AI Agent Framework

Choose a framework you want to connect Ploid with:

- [ChatGPT](https://composio.dev/toolkits/ploid/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/ploid/framework/claude-cowork)
- [Hermes](https://composio.dev/toolkits/ploid/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/ploid/framework/atomic-agent)

## Related Toolkits

- [Aeroleads](https://composio.dev/toolkits/aeroleads) - Aeroleads is a B2B lead generation platform for finding business emails and phone numbers. Grow your sales pipeline faster with powerful prospecting tools.
- [Autobound](https://composio.dev/toolkits/autobound) - Autobound is an AI-powered sales engagement platform that crafts hyper-personalized outreach and insights. It helps sales teams boost response rates and close more deals through tailored content and recommendations.
- [Better proposals](https://composio.dev/toolkits/better_proposals) - Better Proposals is a web-based tool for crafting and sending professional proposals. It helps teams impress clients and close deals faster with slick, easy-to-use templates.
- [Bidsketch](https://composio.dev/toolkits/bidsketch) - Bidsketch is a proposal software that helps businesses create professional proposals quickly and efficiently. It streamlines the proposal process, saving time while boosting client win rates.
- [Bolna](https://composio.dev/toolkits/bolna) - Bolna is an AI platform for building conversational voice agents. It helps businesses automate support and streamline interactions through natural, voice-powered conversations.
- [Botdog](https://composio.dev/toolkits/botdog) - Botdog is a LinkedIn outreach platform for managing campaigns, leads, messages, analytics, and sending accounts. It helps sales teams run outbound workflows and track performance from one place.
- [BotPenguin](https://composio.dev/toolkits/botpenguin) - BotPenguin is an AI chatbot platform for customer messaging, contacts, and conversations. It helps teams manage bot-led support and lead engagement across channels.
- [Botsonic](https://composio.dev/toolkits/botsonic) - Botsonic is a no-code AI chatbot builder for easily creating and deploying chatbots to your website. It empowers businesses to offer conversational experiences without writing code.
- [Botstar](https://composio.dev/toolkits/botstar) - BotStar is a comprehensive chatbot platform for designing, developing, and training chatbots visually on Messenger and websites. It helps businesses automate conversations and customer interactions without coding.
- [Callerapi](https://composio.dev/toolkits/callerapi) - CallerAPI is a white-label caller identification platform for branded caller ID and fraud prevention. It helps businesses boost customer trust while stopping spam, fraud, and robocalls.
- [Callingly](https://composio.dev/toolkits/callingly) - Callingly is a lead response management platform that automates immediate call and text follow-ups with new leads. It helps sales teams boost response speed and close more deals by connecting seamlessly with CRMs and lead sources.
- [Callpage](https://composio.dev/toolkits/callpage) - Callpage is a lead capture platform that lets businesses instantly connect with website visitors via callback. It boosts lead generation and increases your sales conversion rates.
- [Charla](https://composio.dev/toolkits/charla) - Charla is a live chat and AI customer-support platform for property teams. It helps manage guest conversations, property contacts, and support knowledge.
- [Chatforma](https://composio.dev/toolkits/chatforma) - Chatforma is a chatbot automation platform for building and managing bots. It helps teams run dialogs, segments, broadcasts, forms, and user updates from one place.
- [Clearout](https://composio.dev/toolkits/clearout) - Clearout is an AI-powered service for verifying, finding, and enriching email addresses. It boosts deliverability and helps you discover high-quality leads effortlessly.
- [Clientary](https://composio.dev/toolkits/clientary) - Clientary is a platform for managing clients, invoices, projects, proposals, and more. It streamlines client work and saves you serious admin time.
- [Convolo ai](https://composio.dev/toolkits/convolo_ai) - Convolo ai is an AI-powered communications platform for sales teams. It accelerates lead response and improves conversion rates by automating calls and integrating workflows.
- [Crisp](https://composio.dev/toolkits/crisp) - Crisp is a customer messaging platform for live chat, contacts, helpdesk, and campaigns. It helps support teams manage customer conversations from one shared workspace.
- [Delighted](https://composio.dev/toolkits/delighted) - Delighted is a customer feedback platform based on the Net Promoter System®. It helps you quickly gather, track, and act on customer sentiment.
- [Docsbot ai](https://composio.dev/toolkits/docsbot_ai) - Docsbot ai is a platform that lets you build custom AI chatbots trained on your documentation. It automates customer support and content generation, saving time and improving response quality.

## Frequently Asked Questions

### Do I need my own developer credentials to use Ploid with Composio?

Yes, Ploid requires you to configure your own API key. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)