Cursor + LinkedIn MCP: AI-Native Sales Workflow for Developers

#TL;DR

Cursor plus Fintalio MCP turns your editor into a sales workstation. Configure Fintalio in Cursor’s MCP settings, point Cursor at the Fintalio token, and the editor’s agent can list contacts, parse CSVs, draft sequences, and launch outreach without leaving your repo. The boring 80% (sourcing, drafting, scheduling) runs as code-reviewed agent loops. The 20% relationship work stays human. Stack cost: €69 per month for Fintalio plus your existing Cursor plan.

#Why does “Cursor as sales workstation” make sense in 2026?

Cursor shipped first-class MCP host support in late 2024, and the Cursor MCP docs confirm any MCP-compliant server can attach via the Settings panel. That means a developer who already lives in Cursor 8 hours per day can pull LinkedIn outreach into the same editor. The friction of context-switching to a SaaS UI disappears.

Three engineering instincts transfer cleanly from code to sales:

• Reproducibility. A prompt is a script. A sequence template is a versioned artifact. A campaign launch is a reviewable diff
• Supervision. The agent proposes, you approve. The allowlist UI is the same pattern as a code review
• Observability. The chat log IS the audit trail. Every tool call is visible inline

The repo becomes the workspace. prospects.csv lives next to package.json. Templates live in templates/. Sequences live in sequences/. You git diff the CSV before the agent launches the campaign. That is a workflow most developers already trust for code, now applied to outbound.

#What does the architecture look like?

The stack has three layers: Cursor as the LLM host, Fintalio’s MCP endpoint as the tool layer, the hosted LinkedIn relay as the data path. Per the Model Context Protocol specification, the host runs the inference, the server exposes tools, and the LLM picks which tool to call at runtime.

+--------------------+                                +-------------------+
| Cursor (LLM host)  |  MCP/JSON-RPC over HTTPS       | Fintalio          |
|  - agent chat      |  ------- tool calls -------->  | /mcp endpoint     |
|  - file context    |  <------ tool results -------  | (19 tools)        |
|  - terminal        |                                +-------------------+
+--------------------+                                          |
        |                                                       v
        |   reads/writes                                +-----------------+
        v                                               | hosted LinkedIn |
+--------------------+                                  | relay           |
| your repo          |                                  +-----------------+
|  - prospects.csv   |
|  - templates/      |
|  - sequences/      |
+--------------------+

Cursor reads your local repo for context. The agent reasons about a CSV before it calls Fintalio. The Fintalio endpoint exposes 19 tools (9 read, 9 write, 1 execute) and 3 resources. The hosted LinkedIn relay handles the platform session under the hood. You never write a LinkedIn API client.

#How do you set it up in under 20 minutes?

Three steps. Roughly 7 minutes per step if your laptop is cooperative.

#Step 1: generate a Fintalio MCP token

Log into the Fintalio dashboard. Go to Settings > Tokens API & MCP. Click “New token,” name it cursor-mac-personal (or similar). Copy the value the moment it appears. Per the Laravel Sanctum documentation, tokens are stored as SHA-256 hashes server-side. Plaintext is shown exactly once.

#Step 2: configure Cursor’s MCP settings

Open Cursor. Settings > MCP > Add new server. Paste this block, replacing the placeholder token:

{
  "mcpServers": {
    "fintalio": {
      "url": "https://fintalio.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN_HERE"
      }
    }
  }
}

Save. Restart the Cursor agent panel. The green “tools available” indicator should appear within a few seconds. If it stays red, you have one of three problems: a typo in the token, the wrong URL, or a corporate firewall blocking outbound HTTPS to fintalio.com.

#Step 3: create your “sales repo” structure

Inside your project (or a dedicated sales-ops/ repo), scaffold this tree:

sales-ops/
  prospects/
    q3-revops-leads.csv
  templates/
    invite-revops-v3.md
    follow-up-v2.md
  sequences/
    q3-revops.yaml
  prompts/
    triage.md
    draft-first-touch.md
  ops.md

Why this layout matters: every action becomes a diff. Every campaign becomes a pull request. Every prompt becomes a reusable artifact. git log is your audit trail. git blame tells you who changed the ICP filter last quarter. That is sales-as-code, and it scales the way engineering scales.

#What are the 5 agent loops you’ll run every week?

Five loops cover roughly 80% of a weekly outbound motion. Each is a Cursor chat session with a tight, repeatable prompt. Run them in order. Pin the canonical 19-tool list at the top of prompts/triage.md to prevent the agent from hallucinating tool names.

#Loop A: daily account health

Prompt: “Call GetAccountStatus, summarize daily quota left, flag if under 20% remaining.”

Frequency: every morning, takes 30 seconds. Purpose: prevents you from launching a sequence into an already-saturated LinkedIn account. The 50 messages per day plus 50 connections per day platform caps are real ceilings, not soft guidelines.

#Loop B: prospect ingestion review

Prompt: “Read prospects/q3-revops-leads.csv, call ParseCsv, surface any rows with missing required fields. Return a table of failing rows.”

The agent does the boring validation. You commit the fix. Data quality stays at the bar you set. This loop catches the most common failure mode in outbound: junk rows that the agent then dutifully writes into your CRM.

#Loop C: sequence drafting

Prompt: “Read templates/invite-revops-v3.md. Propose 3 variants for the Q3 RevOps target persona. Do NOT call any write tools.”

Three drafts in chat. You pick one. Commit it as invite-revops-v4.md. The ideation cycle stays human. The iteration is fast. Variants live in version control, so you can A/B them across quarters.

#Loop D: sequence launch (the supervised one)

Prompt: “Use CommitCsv to import the validated CSV into group Q3-RevOps. Then create a sequence template from templates/invite-revops-v4.md. STOP before LaunchSequence. Show me the launch plan.”

The agent assembles the launch. You review the plan: row count, scheduled send windows, template summary, target group. Only then do you call LaunchSequence manually. Agent autonomy stops at the line where reputational risk starts.

#Loop E: reply triage (advisory only)

Prompt: “List the 10 contacts whose last_replied_at is most recent. Suggest 3 follow-up moves for each based on their contact metadata.”

Caveat: the agent cannot read or send LinkedIn DMs from the current 19-tool surface. There is no ReadInbox, no SendMessage. Treat this loop as advisory using contact metadata only. You do the relationship work in your actual inbox.

#How do the 19 tools map to these workflows?

Each loop calls specific tools. The list below uses exact tool names from the Fintalio MCP server. Forbidden inventions (SearchProfiles, SendMessage, ScrapeProfile, ReadInbox, AdvancedSearch, PublishPost, ReadFeed, WebhookSubscribe) do not exist on the surface. If the agent tries to call one, it will fail.

Pin this table in prompts/triage.md. The agent re-reads system prompts each conversation, so a canonical list lives in version control and gets refreshed automatically.

#What’s different about Cursor vs Claude Desktop?

Both hosts run the same MCP protocol, but the developer ergonomics diverge in three ways. Per Cursor’s MCP documentation, Cursor’s strength is file context plus terminal access. Claude Desktop is more chat-shaped.

The differences that matter:

• File context advantage. Cursor reads your CSV directly into the agent context. You can ask, “show me the rows that look like duplicates,” and the LLM reasons about the file before calling Fintalio
• Terminal advantage. git diff prospects.csv lives in the same window as the agent chat. The PR review IS the launch review
• Multi-server advantage. Cursor cleanly supports attaching multiple MCP servers. Pair Fintalio with a Postgres MCP for warehouse joins, or a Notion MCP for ops docs

The thing to watch in Cursor specifically: the agent can be too eager to call write tools because it is optimized for code-edit workflows. Set explicit “stop before X” guardrails in every prompt. We saw an internal demo where the agent called LaunchSequence 0.3 seconds after CommitCsv because the operator forgot the stop instruction.

#What is the 80/20 of using Cursor for sales?

80% of weekly outbound work (list ingestion, validation, draft generation, sequence assembly, scheduling, status reporting) now runs in the editor as supervised agent loops. 20% (the actual reply, the demo, the negotiation, the close) stays in your inbox and on your calendar.

The agent never crosses that line. Not because we banned it, but because the 19-tool surface deliberately does not include DM-read or DM-send tools. That is a design choice, not a missing feature. Auto-replying to LinkedIn DMs is exactly the pattern that triggers account restrictions. Reply handling stays human, where it should be.

For the conceptual deep-dive on the protocol layer, read the LinkedIn MCP pillar. For the Claude Desktop tutorial sibling, see the Claude Desktop walkthrough. For the cost math, the MCP server cost comparison breaks down the TCO.

#What are the most common failure modes?

Four failure modes cover roughly every support ticket we see from Cursor users in their first week. Each maps to a clear fix.

• The agent invents a tool name that is not in the 19-tool list. Fix: re-pin the canonical list in prompts/triage.md and reference it explicitly at the top of each conversation
• The agent calls LaunchSequence without confirmation. Fix: tighten the system prompt with “Never call write tools without explicit human ‘go’.” Cursor’s agent is eager; the guardrail is your job
• Token leakage via committed config. Fix: never commit .cursor/mcp.json if it contains a plaintext token. Use a local-only file, or environment-variable indirection
• Rate-limited (429) on the MCP endpoint. Fix: 120 requests per minute per token is the hard ceiling. Pace the agent loop. Chunk large CSVs into 50-row batches

None of these require code changes inside Fintalio. They are all prompt hygiene and token hygiene.

#FAQ

#Does Cursor’s MCP support differ from Claude Desktop’s?

Both hosts implement the same MCP protocol per the Model Context Protocol spec. The differences are ergonomic: Cursor offers stronger file context and terminal integration; Claude Desktop is more chat-shaped. Either host works with Fintalio’s /mcp endpoint. Pick the host you already use 8 hours per day.

#Can I share my Fintalio token with my Cursor team workspace?

Technically yes, structurally no. A shared token loses the per-machine audit trail and you cannot rotate just one seat. Best practice: one token per developer, named (cursor-mac-alice, cursor-mac-bob). Revocation stays granular. Cursor’s team workspace settings should not contain a plaintext shared token.

#Can the agent read my prospect’s LinkedIn profile from inside Cursor?

No. The current 19-tool Fintalio surface does not include SearchProfiles, ScrapeProfile, or any profile-read tool. The agent works from operator-provided CSVs and platform-native contact data. If you need profile enrichment, attach a second MCP server (an enrichment provider) and let the agent compose calls across both.

#What if I want to use a custom LLM (Claude Sonnet vs GPT-5) for the agent?

Cursor exposes a model picker in Settings. Switch between Anthropic and OpenAI models without touching the Fintalio config. The MCP server is model-agnostic; only the host needs to support MCP. Token costs vary materially between models; the cost comparison covers the math.

#Is the workflow CI-able, can I run sequences from a GitHub Action?

The Fintalio MCP endpoint uses Sanctum tokens that work from any client, including a GitHub Action. You would call the /mcp JSON-RPC endpoint directly, bypassing the LLM host. That is power-user territory. Document the failure modes carefully if you put this in CI; unsupervised launches without human review carry reputational risk.

#Wrap-up: what does success look like at minute 20?

Three artifacts. A configured Cursor MCP server with a green indicator. A sales-ops/ repo tree with prospects, templates, sequences, and prompts. A first supervised run that ingests a CSV, drafts a sequence, and stops before launch. The agent has done the boring 80%. The relationship 20% is on your calendar.

If you want to ship the workflow today, register for the single €69 per month plan. MCP access is bundled. The MCP section on the homepage has the one-paste config for Cursor and Claude Desktop. Pair it with the LinkedIn MCP pillar for the protocol context.

Repo as CRM. Prompts as scripts. Sequences as PRs. Three principles, one editor, one €69 monthly line item. The rest is craft.