Advanced Targeting

Take your company discovery to the next level with advanced targeting techniques including multi-entity ICPs, contact density controls, and iterative refinement.

Prerequisites

Before starting, ensure you have:

Completed the Quickstart guide
Understanding of ICPs and entity types
Your API key (see Authentication)

Multi-entity ICPs allow you to discover both companies and contacts in a single workflow. Define a parent entity (typically company) and child entities (typically person) with targeting criteria for each.

Entity Target Configuration

Each entity target in your ICP includes:

Field	Type	Description
`entity_type`	string	Entity type: `company` or `person`
`description`	string	Targeting criteria and enrichment fields
`root`	boolean	`true` for the parent entity
`desired_count`	integer	Contacts per parent (child entities only)

Creating a Multi-Entity ICP

from linkt import Linkt
 
client = Linkt()
 
icp = client.icp.create(
    name="Healthcare SaaS VPs",
    description="VP+ decision makers at healthcare SaaS companies",
    mode="discovery",
    entity_targets=[
        {
            "entity_type": "company",
            "root": True,
            "description": """## Criteria
- Healthcare technology sector
- 50-500 employees
- Series A or B funding
- US or Canada headquarters
 
## Enrichment Fields
- healthcare_focus: Specific healthcare verticals (mental health, dental, etc.)
- tech_stack: Primary technologies and platforms"""
        },
        {
            "entity_type": "person",
            "root": False,
            "desired_count": 3,
            "description": """## Criteria
- VP or C-level title
- Engineering, Product, or Sales department
- Current role for 1+ years
 
## Enrichment Fields
- decision_scope: Evidence of budget authority"""
        }
    ]
)

Response:

{
  "id": "507f1f77bcf86cd799439011",
  "name": "Healthcare SaaS VPs",
  "mode": "discovery",
  "entity_targets": [
    {
      "entity_type": "company",
      "root": true,
      "description": "## Criteria\n- Healthcare technology sector...",
      "desired_count": null
    },
    {
      "entity_type": "person",
      "root": false,
      "description": "## Criteria\n- VP or C-level title...",
      "desired_count": 3
    }
  ],
  "created_at": "2025-01-06T10:00:00Z"
}

Result Expectations

With this configuration:

Companies: Linkt discovers companies matching your criteria
Contacts: For each company, up to 3 people matching the person criteria are discovered
Enrichment: Both entity types receive their specified custom fields

Root Entity

The root: true entity is the primary search target. Child entities are discovered for each root entity found. Only one entity target can be root.

Desired Count Configuration

The desired_count field controls how many child entities to discover per parent. This is essential for contact density control.

Configuration Options

Value	Result
`1` (default)	1 contact per company
`3`	3 contacts per company
`5`	5 contacts per company
`10` (max)	10 contacts per company

Setting Desired Count

from linkt import Linkt
 
client = Linkt()
 
icp = client.icp.create(
    name="Enterprise Accounts + Contacts",
    mode="discovery",
    entity_targets=[
        {
            "entity_type": "company",
            "root": True,
            "description": """## Criteria
- Enterprise B2B SaaS
- 500+ employees"""
        },
        {
            "entity_type": "person",
            "desired_count": 5,
            "description": """## Criteria
- Director+ level
- IT or Engineering department"""
        }
    ]
)

Practical Guidelines

Scenario	Recommended Count
Initial outreach	1-2
Multi-threaded sales	3-5
Account-based marketing	5-10
Research/intelligence	1

Credit Usage

Higher desired_count values consume more credits per company discovered. Balance contact density with your budget.

Filtering Strategies

Entity target descriptions support multiple criteria categories for precise targeting.

Criteria Categories

Category	Purpose	Examples
Location	Geographic targeting	"North America", "San Francisco Bay Area"
Size	Company/team sizing	"50-500 employees", "Mid-market"
Industry	Vertical/sector focus	"B2B SaaS", "Healthcare tech", "Fintech"
Funding	Investment stage	"Series A or B", "Profitable and growing"
Technology	Tech stack preferences	"Using Salesforce", "React stack"
Signals	Behavioral indicators	"Recently hired VP Sales", "Expanding markets"
Exclusion	Negative targeting	"NOT enterprise (>1000)", "Exclude agencies"

Combining Criteria

Structure your entity target description with clear sections:

## Criteria
- B2B SaaS companies (Industry)
- 50-200 employees (Size)
- Series A or B funding (Funding)
- US headquarters (Location)
- Using modern tech stack (Technology)
- NOT consulting or agencies (Exclusion)
 
## Enrichment Fields
- primary_product: Main product or service offered
- tech_stack: Key technologies and frameworks used

Example: Multi-Criteria ICP

from linkt import Linkt
 
client = Linkt()
 
icp = client.icp.create(
    name="AI Startups - West Coast",
    mode="discovery",
    entity_targets=[
        {
            "entity_type": "company",
            "root": True,
            "description": """## Criteria
- AI/ML-focused technology company
- Series A through Series C funding
- 20-200 employees
- Headquarters in California, Washington, or Oregon
- NOT consulting firms or agencies
- Founded after 2018
 
## Enrichment Fields
- ai_focus_area: Primary AI/ML application (NLP, computer vision, etc.)
- notable_customers: Known enterprise customers
- recent_news: Latest funding or product announcements"""
        }
    ]
)

Performance Optimization

Optimize ICP Descriptions

Practice	Impact
Be specific	Fewer false positives
Use clear categories	Better matching
Include exclusions	Filters irrelevant results
Limit enrichment fields	Faster processing

Batch Size Recommendations

Dataset Size	Approach
< 50 companies	Single search task
50-200 companies	Split into 2-3 tasks
200+ companies	Multiple focused ICPs

Credit-Efficient Patterns

Start narrow, expand later — Begin with strict criteria, loosen if needed
Use exclusions — Filter out obvious non-matches upfront
Limit contact count — Start with 1-2 contacts, increase for promising accounts
Reuse ICPs — Create reusable ICPs for recurring searches

Complete Example

Here's a full workflow for multi-entity discovery:

from linkt import Linkt
import time
 
client = Linkt()
 
def advanced_search(icp_config):
    """Execute advanced multi-entity search."""
 
    # Step 1: Create multi-entity ICP
    print("Creating ICP...")
    icp = client.icp.create(**icp_config)
    icp_id = icp.id
    print(f"  ICP created: {icp_id}")
 
    # Step 2: Create sheets for each entity type
    sheets = {}
    for target in icp_config["entity_targets"]:
        entity_type = target["entity_type"]
        print(f"Creating {entity_type} sheet...")
        sheet = client.sheet.create(
            name=f"{icp_config['name']} - {entity_type}",
            icp_id=icp_id,
            entity_type=entity_type
        )
        sheets[entity_type] = sheet.id
 
    # Step 3: Create search task
    print("Creating search task...")
 
    # Get desired_contact_count from person entity target
    desired_count = 1
    for target in icp_config["entity_targets"]:
        if target["entity_type"] == "person" and "desired_count" in target:
            desired_count = target["desired_count"]
 
    task_config = {
        "type": "search",
        "desired_contact_count": desired_count
    }
 
    task = client.task.create(
        name=f"Search: {icp_config['name']}",
        flow_name="search",
        deployment_name="main",
        sheet_id=sheets["company"],
        task_config=task_config
    )
    task_id = task.id
    print(f"  Task created: {task_id}")
 
    # Step 4: Execute
    print("Executing search...")
    run = client.task.execute(task_id=task_id, icp_id=icp_id)
    run_id = run.run_id
 
    # Step 5: Wait for completion
    print("Waiting for completion...")
    while True:
        status = client.run.retrieve(run_id=run_id)
 
        if status.status == "COMPLETED":
            break
        elif status.status in ["FAILED", "CANCELED", "CRASHED"]:
            raise Exception(f"Search failed: {status.error}")
 
        time.sleep(10)  # Poll every 10 seconds
 
    # Step 6: Get results
    results = {}
    for entity_type, sheet_id in sheets.items():
        entities = client.entity.list(sheet_id=sheet_id)
        results[entity_type] = entities
        print(f"  {entity_type}: {entities.total} entities")
 
    return {
        "icp_id": icp_id,
        "task_id": task_id,
        "sheets": sheets,
        "results": results
    }
 
# Example: Multi-entity search
result = advanced_search({
    "name": "Healthcare SaaS Decision Makers",
    "description": "VPs at healthcare technology companies",
    "mode": "discovery",
    "entity_targets": [
        {
            "entity_type": "company",
            "root": True,
            "description": """## Criteria
- Healthcare technology sector
- B2B SaaS business model
- 50-500 employees
- Series A through Series C funding
- US headquarters
 
## Enrichment Fields
- healthcare_vertical: Specific healthcare focus area
- key_products: Main product offerings"""
        },
        {
            "entity_type": "person",
            "desired_count": 3,
            "description": """## Criteria
- VP, Director, or C-level title
- Engineering, Product, or Sales department
- Decision-making authority
 
## Enrichment Fields
- focus_area: Primary responsibility area"""
        }
    ]
})
 
print(f"\nFound {result['results']['company'].total} companies")
print(f"Found {result['results']['person'].total} contacts")

Next Steps

Contact Discovery — Person-focused search workflows
ICPs Reference — Complete ICP documentation
Custom Fields — Extending entity schemas