Account Monitoring

Set up monitoring for specific companies in your sheets to track funding rounds, leadership changes, product launches, and other significant events. Unlike topic monitoring, account monitoring watches entities you've already discovered.

Prerequisites

Before starting, ensure you have:

Completed the Topic Monitoring guide
A sheet with existing entities to monitor (from search or CSV import)
Your API key (see Authentication)

Understanding Account vs Topic Monitoring

Account monitoring (signal-sheet) watches entities from an existing sheet, while topic monitoring (signal-topic) discovers signals based on search criteria. Use account monitoring when you have a defined list of companies to track—your target accounts, customers, competitors, or prospects already in Linkt.

ICP Modes

Both monitoring types require an ICP with mode: "monitoring". See ICPs for mode details.

Step 1: Identify Your Source ICP

Account monitoring requires a source ICP with existing entities. This is typically a discovery ICP from a previous search or CSV import.

# List your ICPs to find the source
curl -X GET "https://api.linkt.ai/v1/icp" \
  -H "x-api-key: your-api-key"

Response:

{
  "icps": [
    {
      "id": "507f1f77bcf86cd799439011",
      "name": "Enterprise SaaS Targets",
      "mode": "discovery",
      "entity_targets": [
        {"entity_type": "company", "root": true}
      ],
      "created_at": "2025-01-01T10:00:00Z"
    }
  ]
}

Note the id of the ICP containing entities you want to monitor.

Step 2: Create a Monitoring ICP

Create a separate ICP in monitoring mode for signal detection:

curl -X POST "https://api.linkt.ai/v1/icp" \
  -H "x-api-key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Enterprise Account Signals",
    "description": "Monitor target enterprise accounts for business signals",
    "mode": "monitoring",
    "entity_targets": [
      {
        "entity_type": "company",
        "description": "Enterprise SaaS companies in our target account list",
        "root": true
      }
    ]
  }'

Response:

{
  "id": "507f1f77bcf86cd799439021",
  "name": "Enterprise Account Signals",
  "mode": "monitoring",
  "entity_targets": [...],
  "created_at": "2025-01-06T10:00:00Z"
}

Step 3: Configure the Signal Task

Create a signal task with the signal-sheet configuration. This references your source ICP:

curl -X POST "https://api.linkt.ai/v1/task" \
  -H "x-api-key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Enterprise Account Monitor",
    "description": "Monitor enterprise accounts for funding and leadership signals",
    "flow_name": "signal",
    "deployment_name": "main",
    "icp_id": "507f1f77bcf86cd799439021",
    "task_config": {
      "type": "signal-sheet",
      "source_icp_id": "507f1f77bcf86cd799439011",
      "entity_type": "company",
      "signal_types": [
        {
          "type": "funding",
          "display": "Funding Events",
          "description": "Series A through IPO funding rounds, grants, and capital raises"
        },
        {
          "type": "leadership_change",
          "display": "Leadership Changes",
          "description": "New CEO, CTO, CFO, or other C-suite appointments"
        },
        {
          "type": "product_launch",
          "display": "Product Launches",
          "description": "New products, major features, or significant updates"
        },
        {
          "type": "expansion",
          "display": "Expansion",
          "description": "Geographic expansion, new offices, or market entries"
        }
      ],
      "monitoring_frequency": "daily",
      "webhook_url": "https://your-server.com/webhooks/linkt"
    }
  }'

SignalSheetConfig Fields

Field	Required	Description
`type`	Yes	Config discriminator (must be `signal-sheet`)
`source_icp_id`	Yes	ID of the ICP containing entities to monitor
`entity_type`	No	Entity type to monitor (default: `company`)
`signal_types`	Yes	Array of signal types to detect
`monitoring_frequency`	No	`daily`, `weekly` (default), or `monthly`
`entity_filters`	No	MongoDB query to filter entities
`webhook_url`	No	HTTPS URL to receive completion notifications (see Webhooks)

Step 4: Filter Specific Entities

Use entity_filters to monitor a subset of entities:

Filter by Industry

{
  "type": "signal-sheet",
  "source_icp_id": "507f1f77bcf86cd799439011",
  "entity_type": "company",
  "entity_filters": {
    "data.industry.value": "Technology"
  },
  "signal_types": [...]
}

Filter by Employee Count

{
  "entity_filters": {
    "data.employees.value": {"$gte": 500}
  }
}

Filter by Multiple Criteria

{
  "entity_filters": {
    "$and": [
      {"data.industry.value": {"$in": ["Technology", "Healthcare"]}},
      {"data.revenue.value": {"$gte": 10000000}}
    ]
  }
}

MongoDB Query Syntax

Entity filters use MongoDB query syntax. Common operators include $eq, $ne, $gt, $gte, $lt, $lte, $in, $and, $or, and $regex.

Step 5: Execute Monitoring

Execute the task to start signal detection:

curl -X POST "https://api.linkt.ai/v1/task/507f1f77bcf86cd799439022/execute" \
  -H "x-api-key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "icp_id": "507f1f77bcf86cd799439021"
  }'

Response:

{
  "run_id": "507f1f77bcf86cd799439023",
  "flow_run_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "SCHEDULED"
}

Step 6: Retrieve Account Signals

Once monitoring completes, retrieve signals with entity correlation:

curl -X GET "https://api.linkt.ai/v1/signal?icp_id=507f1f77bcf86cd799439021&days=7" \
  -H "x-api-key: your-api-key"

Response:

{
  "signals": [
    {
      "id": "507f1f77bcf86cd799439030",
      "icp_id": "507f1f77bcf86cd799439021",
      "entity_ids": ["507f1f77bcf86cd799439015"],
      "summary": "TechCorp announced $75M Series C funding led by Andreessen Horowitz, bringing total funding to $120M.",
      "signal_type": "funding",
      "signal_display_name": "Funding Events",
      "strength": "HIGH",
      "references": ["https://techcrunch.com/techcorp-series-c"],
      "created_at": "2025-01-06T14:30:00Z"
    },
    {
      "id": "507f1f77bcf86cd799439031",
      "icp_id": "507f1f77bcf86cd799439021",
      "entity_ids": ["507f1f77bcf86cd799439016"],
      "summary": "DataFlow Systems appointed John Smith as new Chief Technology Officer, previously VP Engineering at AWS.",
      "signal_type": "leadership_change",
      "signal_display_name": "Leadership Changes",
      "strength": "HIGH",
      "references": ["https://dataflow.io/blog/new-cto"],
      "created_at": "2025-01-06T11:15:00Z"
    }
  ],
  "total": 8,
  "page": 1,
  "page_size": 20
}

Entity IDs Populated

With account monitoring, entity_ids contains the IDs of the monitored entities, allowing direct correlation between signals and accounts.

Signal-Entity Correlation

Account monitoring signals include entity_ids linking directly to your entities.

Correlating Signals to Accounts

import requests
 
API_KEY = "your-api-key"
BASE_URL = "https://api.linkt.ai/v1"
HEADERS = {"x-api-key": API_KEY}
 
def get_signals_by_account(icp_id, sheet_id, days=7):
    """Get signals organized by account."""
 
    # Get signals
    signals = requests.get(
        f"{BASE_URL}/signal",
        headers=HEADERS,
        params={"icp_id": icp_id, "days": days}
    ).json()["signals"]
 
    # Get entities for context
    entities = requests.get(
        f"{BASE_URL}/sheet/{sheet_id}/entities",
        headers=HEADERS
    ).json()["entities"]
 
    # Create entity lookup
    entity_map = {e["id"]: e for e in entities}
 
    # Organize signals by entity
    signals_by_account = {}
    for signal in signals:
        for entity_id in signal.get("entity_ids", []):
            if entity_id not in signals_by_account:
                signals_by_account[entity_id] = {
                    "entity": entity_map.get(entity_id),
                    "signals": []
                }
            signals_by_account[entity_id]["signals"].append(signal)
 
    return signals_by_account
 
# Usage
results = get_signals_by_account(
    icp_id="507f1f77bcf86cd799439021",
    sheet_id="507f1f77bcf86cd799439012"
)
 
for entity_id, data in results.items():
    entity = data["entity"]
    if entity:
        company_name = entity["data"]["name"]["value"]
        print(f"\n{company_name}:")
        for signal in data["signals"]:
            print(f"  [{signal['signal_type']}] {signal['summary'][:60]}...")

Output Example

TechCorp Inc:
  [funding] TechCorp announced $75M Series C funding led by Andreessen...
  [product_launch] TechCorp launched new AI-powered analytics platform...

DataFlow Systems:
  [leadership_change] DataFlow Systems appointed John Smith as new CTO...
  [expansion] DataFlow Systems opened new engineering office in Austin...

Building Account Intelligence

Aggregate signals per account to build comprehensive intelligence views.

Account Intelligence Dashboard

import requests
from collections import defaultdict
from datetime import datetime, timedelta
 
API_KEY = "your-api-key"
BASE_URL = "https://api.linkt.ai/v1"
HEADERS = {"x-api-key": API_KEY}
 
def build_account_intelligence(monitoring_icp_id, source_sheet_id, days=30):
    """Build account intelligence from signals."""
 
    # Fetch signals
    signals = requests.get(
        f"{BASE_URL}/signal",
        headers=HEADERS,
        params={"icp_id": monitoring_icp_id, "days": days}
    ).json()["signals"]
 
    # Fetch entities
    entities = requests.get(
        f"{BASE_URL}/sheet/{source_sheet_id}/entities",
        headers=HEADERS
    ).json()["entities"]
 
    entity_map = {e["id"]: e for e in entities}
 
    # Build intelligence per account
    intelligence = {}
 
    for entity in entities:
        entity_id = entity["id"]
        company_name = entity["data"]["name"]["value"]
 
        # Get signals for this entity
        entity_signals = [
            s for s in signals
            if entity_id in s.get("entity_ids", [])
        ]
 
        # Calculate metrics
        signal_counts = defaultdict(int)
        high_priority = []
 
        for signal in entity_signals:
            signal_counts[signal["signal_type"]] += 1
            if signal["strength"] == "HIGH":
                high_priority.append(signal)
 
        intelligence[entity_id] = {
            "company_name": company_name,
            "total_signals": len(entity_signals),
            "high_priority_count": len(high_priority),
            "signal_breakdown": dict(signal_counts),
            "recent_high_priority": high_priority[:3],
            "entity_data": entity["data"]
        }
 
    # Sort by activity
    sorted_accounts = sorted(
        intelligence.values(),
        key=lambda x: x["total_signals"],
        reverse=True
    )
 
    return sorted_accounts
 
# Build intelligence
accounts = build_account_intelligence(
    monitoring_icp_id="507f1f77bcf86cd799439021",
    source_sheet_id="507f1f77bcf86cd799439012",
    days=30
)
 
# Display top accounts
print("Top Accounts by Signal Activity:\n")
for account in accounts[:10]:
    print(f"{account['company_name']}")
    print(f"  Total signals: {account['total_signals']}")
    print(f"  High priority: {account['high_priority_count']}")
    print(f"  Breakdown: {account['signal_breakdown']}")
    print()

Signal Priority Scoring

def calculate_signal_score(account_data):
    """Calculate a priority score for an account based on signals."""
    score = 0
 
    # Weight by signal type
    type_weights = {
        "funding": 30,
        "leadership_change": 25,
        "acquisition": 25,
        "expansion": 20,
        "product_launch": 15,
        "hiring_surge": 15,
        "partnership": 10,
        "rfp": 35,  # High intent signal
    }
 
    # Weight by strength
    strength_multipliers = {
        "HIGH": 3,
        "MEDIUM": 2,
        "LOW": 1
    }
 
    for signal in account_data.get("recent_high_priority", []):
        base_score = type_weights.get(signal["signal_type"], 5)
        multiplier = strength_multipliers.get(signal["strength"], 1)
        score += base_score * multiplier
 
    return score
 
# Add scores and sort
for account in accounts:
    account["priority_score"] = calculate_signal_score(account)
 
priority_accounts = sorted(accounts, key=lambda x: x["priority_score"], reverse=True)

Scheduled Monitoring

Set up recurring monitoring with appropriate frequency:

Monitoring Frequency Options

Frequency	Use Case	Typical Accounts
`daily`	High-priority targets, active deals	10-50
`weekly`	General target accounts	50-500
`monthly`	Extended watchlist	500+

Example: Daily High-Priority Monitoring

{
  "type": "signal-sheet",
  "source_icp_id": "507f1f77bcf86cd799439011",
  "entity_filters": {
    "data.priority.value": "high"
  },
  "signal_types": [
    {"type": "funding", "display": "Funding", "description": "Any funding activity"},
    {"type": "leadership_change", "display": "Leadership", "description": "Executive changes"},
    {"type": "rfp", "display": "RFP", "description": "Procurement activity"}
  ],
  "monitoring_frequency": "daily"
}

Complete Example

Full workflow for setting up account monitoring:

import requests
import time
 
API_KEY = "your-api-key"
BASE_URL = "https://api.linkt.ai/v1"
HEADERS = {"x-api-key": API_KEY, "Content-Type": "application/json"}
 
def setup_account_monitoring(source_icp_id, signal_types, entity_filters=None):
    """Set up account monitoring for an existing ICP."""
 
    # Step 1: Create monitoring ICP
    print("Creating monitoring ICP...")
    monitoring_icp = requests.post(
        f"{BASE_URL}/icp",
        headers=HEADERS,
        json={
            "name": "Account Signal Monitor",
            "description": "Monitor accounts for business signals",
            "mode": "monitoring",
            "entity_targets": [{
                "entity_type": "company",
                "description": "Monitored target accounts",
                "root": True
            }]
        }
    ).json()
    monitoring_icp_id = monitoring_icp["id"]
    print(f"  Monitoring ICP: {monitoring_icp_id}")
 
    # Step 2: Create signal task
    print("Creating signal task...")
    task_config = {
        "type": "signal-sheet",
        "source_icp_id": source_icp_id,
        "entity_type": "company",
        "signal_types": signal_types,
        "monitoring_frequency": "daily"
    }
 
    if entity_filters:
        task_config["entity_filters"] = entity_filters
 
    task = requests.post(
        f"{BASE_URL}/task",
        headers=HEADERS,
        json={
            "name": "Account Signal Monitor Task",
            "flow_name": "signal",
            "deployment_name": "main",
            "icp_id": monitoring_icp_id,
            "task_config": task_config
        }
    ).json()
    task_id = task["id"]
    print(f"  Task: {task_id}")
 
    # Step 3: Execute
    print("Executing monitoring...")
    run = requests.post(
        f"{BASE_URL}/task/{task_id}/execute",
        headers=HEADERS,
        json={"icp_id": monitoring_icp_id}
    ).json()
    run_id = run["run_id"]
 
    # Step 4: Wait for completion
    print("Waiting for completion...")
    while True:
        status = requests.get(
            f"{BASE_URL}/run/{run_id}",
            headers={"x-api-key": API_KEY}
        ).json()
 
        if status["status"] == "COMPLETED":
            break
        elif status["status"] in ["FAILED", "CANCELED", "CRASHED"]:
            raise Exception(f"Monitoring failed: {status.get('error')}")
 
        time.sleep(10)  # Poll every 10 seconds
 
    # Step 5: Get signals
    print("Retrieving signals...")
    signals = requests.get(
        f"{BASE_URL}/signal",
        headers={"x-api-key": API_KEY},
        params={"icp_id": monitoring_icp_id, "days": 7}
    ).json()
 
    print(f"\nFound {signals['total']} signals")
 
    return {
        "monitoring_icp_id": monitoring_icp_id,
        "task_id": task_id,
        "signals": signals["signals"]
    }
 
# Set up monitoring
result = setup_account_monitoring(
    source_icp_id="507f1f77bcf86cd799439011",
    signal_types=[
        {
            "type": "funding",
            "display": "Funding Events",
            "description": "Investment rounds and capital raises"
        },
        {
            "type": "leadership_change",
            "display": "Leadership Changes",
            "description": "C-suite and executive appointments"
        },
        {
            "type": "expansion",
            "display": "Expansion",
            "description": "New offices, markets, or geographic expansion"
        },
        {
            "type": "hiring_surge",
            "display": "Hiring Surge",
            "description": "Significant increase in job postings"
        }
    ],
    entity_filters={
        "data.employees.value": {"$gte": 100}
    }
)
 
# Print signals
for signal in result["signals"][:5]:
    print(f"\n[{signal['signal_type'].upper()}] {signal['summary']}")

Next Steps

Topic Monitoring — Monitor by topic instead of accounts
Webhooks — Receive HTTP notifications when workflows complete
Signal Types Reference — Understanding all signal types
Signals Reference — Signal data structure

On this page