How to Automate Warm Intros Across Your Network

When you use Village.ai, it functions strictly as a request-response API. It lacks the internal webhooks or event-listeners required to initiate a workflow on its own.

Because there are no native triggers, Activepieces must prompt every automation by acting as the external event handler. This forces you to manage the timing of an operation outside of the Village environment.

Village.ai has zero triggers, only 40 actions

What Village.ai actually is

By design, Village.ai is an intelligence layer created to enrich lead data and map professional networks through a fixed set of 40 outbound actions. It doesn't store persistent state or monitor external apps for changes.

Instead, it waits for an authenticated POST request to execute a specific task. This architecture ensures that the platform remains a stateless utility rather than a comprehensive automation hub. It shifts the burden of logic and timing to your own infrastructure.

The functional scope of the intelligence layer

The 40 actions available in the Village library are categorized into four functional pillars that define the scope of its intelligence. These capabilities allow an external orchestrator to treat the platform as a specialized consultant that only speaks when spoken to.

Person search and identity verification actions form the first pillar, allowing you to reveal email addresses or find social profiles based on partial data. This ensures that the person you are targeting actually exists and is reachable at a verified endpoint.

Company enrichment and relationship mapping constitute the second pillar, where actions like check_company_paths scan for bridges between your team and a target organization. This layer identifies the specific board members, investors, or former colleagues who can facilitate an introduction.

Relationship scoring and list management make up the third pillar, providing tools to rank prospects by the strength of their connections. These actions allow you to sort a list of 500 leads to find the 10 where you have the highest social leverage.

Project agents and bulk processing represent the final pillar, designed for high-volume research tasks. These actions allow an agent to autonomously build lists or refresh the enrichment data for an entire CRM segment in a single execution cycle.

Why 40 actions and 0 triggers is the whole story

Metered costs define the platform’s utility: every discrete action consumes a specific number of credits from a user's balance. The chart above shows how quickly a high-volume automated search can deplete a budget if the external trigger isn't tightly filtered.

50 credits is the price of running a project agent, according to the Village.ai pricing page. A single complex research task is roughly fifty times more expensive than a simple data lookup.

Building a list of 25 leads with AI consumes 16 credits. You must verify your targeting criteria before execution to avoid wasting bulk credits on irrelevant prospects.

6 credits are consumed for an AI search returning 10 results. Identifying warm intro paths to one person costs 5 credits. These mid-tier costs require you to trigger searches only for high-value targets.

Finally, revealing an email address or enriching a profile in realtime costs 1 credit each. This allows for high-volume, low-cost verification of individual contact records.

What 'request-response only' rules out

Because there are no triggers, Village.ai can't react to live changes in your tech stack, such as a new lead appearing in a CRM. An external script must manually send lead info to the API because Village can't see a new entry in a database.

Activepieces allows a connector to run two ways at once: as a step in a flow and as a tool schema on a per-project MCP server.

This means any integration, including Village, is immediately reachable from Claude, ChatGPT, or Cursor without a second migration or re-integrating a catalog for your agents.

Why Village cannot initiate warm intros

Village.ai functions exclusively as a destination for data rather than a source of events. It lacks the internal mechanism to detect when a business process needs to begin.

Because the Activepieces integration for Village contains 40 distinct actions but 0 triggers, the platform can't watch for new opportunities. It must wait for an external system to push instructions to it.

The case for Village firing its own trigger

A self-triggering workflow would theoretically allow Village to manage the entire lifecycle of a warm intro, from identifying a target contact to executing the outreach.

If the platform could monitor its own internal state, you could set a rule where a specific relationship score threshold automatically initiates a request for an introduction. Nobody would need a third-party service to poll the API.

It reduces the number of failure points in a sensitive networking sequence.

Why Village needs an external trigger platform

The architectural reality of the platform is that Village acts as a passive toolset that requires an upstream engine to define the start of any automation. To initiate a workflow, you must configure a separate automation platform to monitor one of these external events.

The architectural reality of the platform is that Village acts as a passive toolset that requires an upstream engine to define the start of any automation.

1. A new entry in a Customer Relationship Management system signals that a lead is ready for enrichment. Systems like HubSpot or Salesforce provide these signals.
2. Moving a job seeker to a specific stage in an Applicant Tracking System requires a background check or intro. This applies to platforms like Ashby or Greenhouse.
3. A user submits a web form. This provides the raw data needed for the agent to begin processing.
4. A scheduled clock or timer reaches a specific interval. This forces the system to check for updates.

By offloading the timing to specialized event-handlers, the platform avoids the maintenance burden of building native integrations for every possible business event. This reliance on external signals ensures that Village remains a portable agent tool rather than a siloed ecosystem.

Four supported warm-intro automation patterns

Village’s request-response architecture enables four specific automation patterns that transform static database entries into actionable warm-introduction paths. Because the platform operates as a stateless engine, it relies on external triggers to initiate a search across the Village relationship graph of 4.77 billion verified connections.

The following table demonstrates how different external events map to specific Village tools to produce these networking insights:

Workflow Name	Trigger	Primary Village Tool
New Account	CRM Record	check_company_paths
Target List	Manual Sort	sort_companies
New Candidate	ATS Stage	get_person_paths
Nightly Bulk	Schedule	get_person_paths_bulk

This structure ensures the system only fetches relationship data when a specific business milestone occurs, preventing the accumulation of stale networking data in the system of record.

New account in the CRM

When a new entry appears in a Customer Relationship Management system, it triggers a path check. Salesforce or similar tools identify which internal team members have the strongest bridge to the new prospect.

By calling check_company_paths the moment you create a record, the sales representative receives a list of warm intro options immediately. This is faster than manually researching the prospect’s board members or former colleagues.

Ranking target accounts with sort_companies

The sort_companies tool reorders a list based on the density of accessible connections when you manually initiate a sort on a defined list of organizations.

This allows a business development representative to prioritize their daily outreach based on where they have the highest probability of a response, rather than working through an alphabetical list of leads.

Finding mutual connections for new ATS candidates

Moving a job seeker to a specific stage in an Applicant Tracking System prompts the get_person_paths tool. Greenhouse or other systems use this to find mutual connections between the candidate and the hiring team.

This surfaced data allows recruiters to perform backchannel references or request internal vouchers. These steps reduce the risk of a bad hire by validating the candidate's history through trusted intermediaries.

Bulk refreshing saved prospect lists overnight

To refresh connection data for hundreds of entities at once, a scheduled cron job targeting a saved list of prospects uses get_person_paths_bulk.

This ensures that even as people change jobs or boards among the 775 million searchable profiles in the database, the sales team’s intelligence remains current without requiring manual per-record updates.

Village.ai credits turn a schedule into a budget

Village.ai operates on a metered consumption model where every discrete data retrieval or intelligence task carries a specific credit weight.

This pricing structure forces a shift from "run everything" mentalities to a "run what is necessary" strategy. Every automated trigger directly impacts the monthly operational budget.

What each action costs in dollars

The unit cost of an automation depends entirely on the depth of the data requested. A simple contact reveal is significantly cheaper than a multi-step intelligence search. The following table illustrates how different API actions consume credits and their resulting impact on the bottom line.

Action	Credit Cost	Dollar Cost (at $0.02/credit)
Path Lookup	5	$0.10
Email Reveal	1	$0.02
AI Search	6	$0.12
Refresh Enrichment	0	$0.00

This tiered cost structure ensures that you only pay a premium for complex relationship mapping while basic identity verification remains a commodity. Because cached enrichments carry no cost, developers are encouraged to design systems that favor data re-use over redundant external calls.

How a nightly sync exhausts your credit plan

A standard monthly credit allotment will be exhausted in a single execution by a naive automation that triggers a full enrichment for every row in a large database.

If a customer relationship management platform like Salesforce triggers a path lookup for every one of its five hundred daily leads, the resulting daily cost would consume the entire credit ceiling of a mid-tier plan.

This lack of discrimination turns a routine synchronization into a financial liability. The system treats a low-priority cold lead with the same resource intensity as a high-value target.

Fixing credit burn with check-first and cadence

Architecting a sustainable automation requires a multi-layered filtering process to ensure credits are only spent on high-probability opportunities.

Implement a "check-first" logic that queries the local database for existing, recent enrichment data to avoid paying for information the organization already owns.

Group individual triggers into bulk API calls to reduce the overhead of multiple connection handshakes and gain more granular control over daily spend limits.

Set a specific cadence for high-cost actions, such as path lookups, so they only execute when a lead moves into a "qualified" status rather than upon initial entry.

Automate the finding, never the ask

The introduction request must remain hand-written and human-approved because a poorly automated outreach consumes a colleague’s social capital rather than a replaceable software credit.

While the logistics of identifying a path to a prospect are predictable, the nuance of a relationship is a non-fungible asset. It can't be recovered once a contact feels processed by a script.

The introduction request must remain hand-written and human-approved because a poorly automated outreach consumes a colleague’s social capital rather than a replaceable software credit.

What is safe to automate

Efficiency gains in networking come from automating the high-volume research tasks that precede the actual conversation.

By offloading the mechanical steps of discovery to a portable agent tool, you ensure your time is spent evaluating the quality of a connection rather than digging for its existence.

The following tasks are safe to delegate to an automated workflow. Scanning the CRM system identifies which internal team members have previously interacted with a specific target account. Cross-referencing LinkedIn profiles against an employee directory finds the shortest path of mutual connections.

Ranking potential introducers based on recent interaction frequency prioritizes those with the warmest current rapport. Logging the status of an outreach attempt in a central database prevents multiple team members from pinging the same contact simultaneously.

Keeping the send and the message human

The final decision to send a request and the specific phrasing used to frame it must remain under direct human control.

Because an automated message lacks the context of private history (such as a recent bereavement or a confidential business pivot) sending a message risks appearing tone-deaf and signaling that the recipient’s time is undervalued.

Keeping the "send" button behind a human gate ensures that you remain the ultimate steward of your colleague’s reputation. A human can weigh the political cost of asking for a favor against the potential value of the lead.

This calculation requires the subjective judgment of a peer rather than the binary logic of a trigger.

How Activepieces triggers Village's warm-intro actions

Activepieces provides the event-driven triggers that the Village platform doesn't natively host, allowing companies like MoneyGram and Funding Societies to run complex automations across their own infrastructure.

Because Village operates as a specialized execution engine for relationship mapping rather than a general-purpose automation suite, it requires an orchestrator to tell it when to begin a search or update a record.

The integration: version, actions, authentication

The official Village integration for Activepieces, version 0.4.4, is a library of forty distinct actions that interface directly with the Village API.

To establish a secure handshake, you enter a Village API token within the Activepieces connection settings. This ensures that every automated request is authenticated against the specific organization’s relationship graph.

This library includes granular functions such as check_company_paths to verify existing connections. It also uses get_company_paths to retrieve the specific chain of introductions.

These tools allow you to build complex logic without writing custom HTTP requests. By using the sort_companies and bulk action features within this integration, a developer can process entire lists of prospects in a single execution cycle.

This reduces the overhead of managing individual API calls for every lead.

How to bridge the functional gap

Activepieces bridges the functional gap by monitoring third-party services for specific events that Village can't see on its own.

Activepieces allows you to generate a custom integration with AI if a specific connector is missing, which is how roughly 60% of the 732 integrations in the open-source monorepo were built.

This ensures that any business event captured in one app can immediately trigger a relationship query in Village, without waiting on a vendor's release queue.

This architecture ensures that warm-intro searches happen the moment a lead is generated. This is more efficient than waiting for a manual batch upload by a human operator.

Setting up your first Village.ai automation on Monday

Village.ai requires an external trigger to initiate its workflow because it functions as a modular agent tool rather than a self-contained automation suite.

By decoupling the start of the process from the enrichment engine, you ensure that Village.ai only activates when specific criteria are met in your primary system of record.

Pick the upstream trigger first

The automation begins in a project management tool like Monday.com, which acts as the system of record where new lead data is initially captured.

When a status column in Monday.com changes to "Ready for Research," it sends a webhook to your automation middleware. This ensures that Village.ai credits are never spent on leads that haven't yet been vetted by your sales development team.

Screening companies with check_company_paths first

Before any deeper data scraping occurs, the first action Village.ai should perform is the check_company_paths function to determine if a viable connection exists.

This initial screen filters out companies where your network has no leverage. This prevents the automation from wasting time and processing power on low-probability prospects.

Once a path is confirmed, the workflow moves from automated research into a drafting phase, but it doesn't send the message immediately.

Automated research and AI drafting are held at a mandatory approval gate: a person verifies the output before any outreach is released.

This manual check ensures that the "warm intro" remains authentic and prevents the reputational damage caused by hallucinated AI biographies.

Throttling API requests to protect your credits

To control the volume of requests sent to the Village.ai API, a delay step or a scheduled batching window must be configured in your middleware.

Because Village.ai charges per successful enrichment, an unthrottled loop could exhaust your monthly credit allocation during a single bulk import of leads.

Implementing a rate limit ensures your automation remains active throughout the entire sales cycle rather than hitting a hard cap in the first week of the month.

Frequently asked questions

Does Village.ai have any webhooks or triggers at all?

Village.ai currently functions exclusively as a destination for external requests, meaning it lacks internal listeners to monitor third-party applications for changes.

Because the platform doesn't provide native triggers, you must rely on an external scheduler or a middleware service to initiate a workflow. This ensures the automation logic remains decoupled from the specific event architecture of the source software.

Can I use Village.ai through Claude or ChatGPT instead of a scheduled job?

Yes, and you do not have to wire it up yourself: Village publishes an MCP server at mcp.village.ai/mcp that installs into Claude and ChatGPT in one click, on every plan including the free one. Once connected, the model can call the same actions a scheduled flow would.

This shifts the burden of logic execution from a rigid time-based schedule to an on-demand, intent-driven interaction.

Can I resell Village.ai access inside my own product?

The platform is available for white-labeling and embedding through its API-first architecture, provided your implementation adheres to their specific developer terms of service. By treating the service as a headless backend component, you can surface its automation capabilities under your own branding.

This enables you to offer sophisticated workflow features to your end users without them ever interacting with the Village.ai dashboard.

How many credits does a typical warm-intro workflow use per month?

Rather than a flat monthly fee, credit consumption is determined by the specific volume of data processed and the complexity of the steps involved.

A standard workflow involving lead enrichment and outreach will consume credits based on the total number of unique contacts identified during the search phase.

It also depends on the volume of outbound messages generated by the language model and the number of external database lookups required to verify contact information.

This consumption model means your costs scale precisely with your output, preventing you from paying for idle capacity during slower sales periods.