MCP: Accounting Firm Leads - AI Agents / Claude / GPT

A Model Context Protocol (MCP) server exposing US accounting / CPA / bookkeeping / payroll / fractional CFO lead intelligence to AI agents. Wraps Seibs.Co/accounting-firm-lead-finder with an agent-callable interface so Claude, GPT, LangChain, Lindy, Crew.ai, and custom LLM workflows can fetch enriched firm records on-demand.

What is MCP?

Model Context Protocol is Anthropic's open standard for letting AI agents discover and call external tools. Instead of stuffing scraping logic into every agent, you expose capabilities as MCP tools and the agent invokes them by name with typed arguments. This actor implements an Apify-hosted MCP server that an agent can reach over HTTPS.

The 5 tools

Tool	Purpose
search_accounting_firms	Broad Google Maps lookup. Args: locations, search_terms, max_results.
get_firm_intel	Single firm deep-dive. Args: business_name, location.
find_firms_by_tech_stack	Filter by detected software (QuickBooks, Xero, Karbon, TaxDome, Lacerte, Drake, ProConnect, UltraTax, Canopy, Jetpack, Liscio, Bill.com). Args: software, locations, max_results.
find_firms_by_specialty	Filter by practice type: tax, bookkeeping, audit, advisory, payroll, cfo_services, forensic, estate, enrolled_agent, wealth.
find_modern_firms	Surface cloud-stack modern firms. Args: locations, min_modern_score (0-1, default 0.6).

Each record returned includes name, address, phone, website, decision-maker emails, detected tech stack, modern_score, and service lines.

How AI agents consume this

1. Discover tools (free, no charge)

curl -X POST "https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"action": "list_tools"}'

Returns { protocolVersion, server, tools: [...] } - the full MCP tool catalog. Agent caches this and uses it to construct tool calls.

2. Invoke a tool

curl -X POST "https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "find_firms_by_tech_stack",
    "args": {
      "software": ["karbon", "taxdome"],
      "locations": ["Austin, TX", "Denver, CO"],
      "max_results": 25
    }
  }'

Response includes the MCP-shaped envelope:

{
  "tool": "find_firms_by_tech_stack",
  "mcp_response": {
    "isError": false,
    "content": [
      {"type": "text", "text": "Top matches: ..."},
      {"type": "json", "json": [{"name": "...", "website": "...", "decision_maker_emails": [...]}]}
    ]
  },
  "results": [ ... ],
  "result_count": 17
}

Integration snippets

Claude (Anthropic SDK, tool-use)

import anthropic, httpx

APIFY_TOKEN = "..."
ANTHROPIC = anthropic.Anthropic()

def mcp_tool_call(tool: str, args: dict) -> dict:
    r = httpx.post(
        f"https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={APIFY_TOKEN}",
        json={"tool": tool, "args": args}, timeout=600,
    )
    return r.json()[0]

# Register the 5 tools with Claude (fetch schemas once via list_tools).
tools = mcp_tool_call("list_tools", {})["mcp_response"]["tools"]
claude_tools = [
    {"name": t["name"], "description": t["description"], "input_schema": t["inputSchema"]}
    for t in tools
]

resp = ANTHROPIC.messages.create(
    model="claude-opus-4-5",
    max_tokens=4096,
    tools=claude_tools,
    messages=[{"role": "user", "content": "Find 10 CPAs in Austin that use Karbon."}],
)
# When resp.stop_reason == "tool_use", call mcp_tool_call(...) and feed back.

LangChain

from langchain.tools import StructuredTool
import httpx

def make_mcp_tool(name, desc, schema):
    def _run(**kwargs):
        r = httpx.post(
            f"https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={APIFY_TOKEN}",
            json={"tool": name, "args": kwargs}, timeout=600,
        )
        return r.json()[0]["results"]
    return StructuredTool.from_function(name=name, description=desc, func=_run)

Lindy

In Lindy, add a Custom Action -> HTTP Request:

• Method: POST
• URL: https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={{secrets.APIFY_TOKEN}}
• Body: { "tool": "{{tool_name}}", "args": {{args_json}} }
• Map the response.results into your workflow.

Crew.ai

from crewai_tools import tool
import httpx

@tool("find_accounting_firms")
def find_accounting_firms(locations: list[str], software: list[str]) -> list[dict]:
    """Find US accounting firms using specific software."""
    r = httpx.post(
        f"https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={APIFY_TOKEN}",
        json={"tool": "find_firms_by_tech_stack", "args": {
            "software": software, "locations": locations, "max_results": 25
        }}, timeout=600,
    )
    return r.json()[0]["results"]

Pricing

• $0.005 per MCP tool call (this actor).
• Plus pass-through of the underlying accounting-firm-lead-finder PPE charges (~$0.015 per premium record). A search returning 25 leads costs roughly $0.005 + 25 * $0.015 = $0.38.

Limits / notes

• Each tool call runs the upstream actor once. Cold-start latency is the upstream's latency (15s - 2min depending on query size).
• find_firms_by_tech_stack and find_modern_firms use client-side filtering on the upstream results, so they may return fewer records than max_results if the filter is strict. The wrapper casts a wider upstream net (3-4x) to compensate.
• All filtering uses the upstream record's detected_tech and modern_score fields. Underlying detection accuracy is what it is.

Underlying actor

Seibs.Co/accounting-firm-lead-finder

Contact

• Email: jtseib@live.com

Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with a single click - no need to re-type search terms, locations, filters, or tier settings every time. Tasks are the foundation for everything that comes next: schedules, monitor mode, and webhook routing all attach to a saved Task, not to the raw actor.

Steps to save your current input as a Task:

1. On this actor's Apify Store page, click Run with your input fully configured.
2. Click the Save as task button at the top of the run page.
3. Name the task something memorable (e.g. Saved CPA query for agent - on-demand).
4. Reload the task page and click Start anytime to re-run with the same inputs.

Tasks unlock the next two features below: scheduling and monitor mode.

Run this weekly with Apify Schedules

Apify Schedules cron-run any saved Task automatically. Pair this with the saved Task above and you get hands-off recurring runs with no manual clicks.

Steps to schedule a Task:

1. Save your input as a Task (see above).
2. Go to https://console.apify.com/schedules and click Create new schedule.
3. Pick your Task and set the cron expression. Common patterns:
   • Daily at 9am UTC: 0 9 * * *
   • Weekly on Mondays at 9am: 0 9 * * 1
   • Monthly on the 1st: 0 9 1 * *
4. Save. Apify will run your Task on that schedule automatically, push the dataset to whatever integrations you have wired up, and fire run-completion webhooks.

Schedules are unusual for MCP wrappers because AI agents invoke them on-demand. Use Tasks for saved configs but skip the cron schedule unless you have a specific batch-run use case.

Monitor mode (v2, beta)

Monitor mode is the v2 evolution of this actor and is currently in BETA. It turns a recurring schedule into a true change-feed instead of a firehose of duplicate records.

How it works:

• When this actor runs under an Apify Schedule, monitor mode is enabled automatically.
• Instead of emitting ALL records every run, it emits ONLY records that are NEW or CHANGED since the last scheduled run.
• A digest record summarizes the delta (X new, Y changed, Z removed) at the top of every run.
• Optional: provide a Slack or email webhook URL in the monitor_webhook_url input field and the digest fires there too, so your team gets the delta in their inbox or channel without polling the dataset.
• Cost: a single scheduled_delta_run event ($0.05) per scheduled run, plus standard PPE on emitted delta records only. Predictable monthly cost, no surprise bills from re-charging for unchanged records.

Monitor mode is rolling out to the top 3 actors first (this one included if it's hotel-motel-lead-finder, google-maps-reviews-pro, or mcp-accounting-firm-leads). Full portfolio coverage by end of June.

Found this useful?

If this actor saved you time or money, please consider leaving a quick review on the Apify Store. Reviews help other buyers find work that solves their problem and let me prioritize the features paying customers actually use. Leave a review: https://apify.com/seibs.co/mcp-accounting-firm-leads#reviews