skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
wannalead.co59 installs

campaign-automation

Prepare, freely customize, approve, launch, and monitor LinkedIn campaigns through Wannalead, from the standard preset to fully custom sequences.

How do I install this agent skill?

npx skills add https://wannalead.co --skill campaign-automation
view source ↗

Is this agent skill safe to install?

No partner audit is available yet. Read the source before installing.

What does this agent skill do?

LinkedIn campaign automation

Build invitation-only campaigns or invitation flows that wait for acceptance before sending a separately personalized message. A visible profile visit and relationship-check step are optional product behavior, not invitation safety prerequisites. Use only Wannalead's public API through the CLI.

First-use context

On a new workspace, start with wannalead-onboarding: its wannalead me identity check is the first Wannalead command, and it loads any saved context from ONBOARDING.md and the durable files. Incomplete onboarding does not block this task. Use the saved context when present, take the rest from the user's request, and ask only for details this task needs. Authentication, the relevant network connection, billing, and endpoint guards still apply.

User freedom is a product invariant

The standard flow is an optional convenience, never the campaign contract's limit. A user may add or remove steps, set each delay, add several follow-ups, choose invitation or message behavior, branch on observed events, use A/B variants, and handle relationship states differently.

When proposing a campaign, state in one short sentence that the suggested sequence is editable and name the main dimensions the user can change. Do not make the user discover the custom builder by objecting to a preset.

Always refresh the live OpenAPI contract

After onboarding, treat live OpenAPI as the source of truth. Before building a preview or mutation, run:

wannalead endpoints
wannalead routes campaigns
wannalead endpoints <name> --examples --json-schema
wannalead openapi path <exact-/v1-route>

Inspect every endpoint the chosen workflow will call and read its full method, schema, parameters, responses, guards, idempotency, deprecation, and replacement metadata. Do this even when an example appears below. Never claim that a campaign shape is unavailable until the complete catalog has been searched with campaign and sequence synonyms and every plausible endpoint has been inspected.

Choose the campaign mode

  • Use the standard two-call workflow for relationship check, invitation when needed, acceptance monitoring, first message, and one no-response follow-up. Every recipient's copy and the timings remain configurable.
  • Use the granular custom builder for multiple follow-ups, invitation-only campaigns, profile visits, A/B variants, custom branches, per-step delays, or different relationship handling. Never reduce the user's requested graph to fit the standard preset.

Durable context

Follow the progressive context rules from wannalead-onboarding. Before selecting targets or drafting copy, load ME.md, COMPANY.md, the relevant ICP from ICPS.md, and OUTREACH-STYLE.md. Refresh CRM exclusions, relationships, conversations, campaign targets, and activity from their authoritative systems. Wannalead owns campaign and recipient state; do not mirror it in local Markdown. Creation, launch, delivery, or one reply does not justify changing durable context. Propose any update and persist it only after user confirmation.

Start from the user's decisions

Before creating the campaign, establish:

  • The exact recipients, using profile URLs or identifiers returned by Wannalead. Never reconstruct or ASCII-normalize a profile identifier.
  • The campaign objective and outreach angle.
  • Whether the user explicitly wants a visible profile visit or a delay before the invitation. Do not add either by default.
  • The delay between acceptance and the message, for example 2, 12, or 24 hours.
  • Whether existing first-degree connections should proceed directly to the message branch. Never try to invite them again.
  • Any sending window, date, and timezone the user cares about (for example "weekdays 9:00-18:00 Paris time"). Apply it with schedule_policy, below.

Do not silently choose a material timing or recipient. If the user gives a relative time such as "tomorrow", state the resulting timing before approval.

Common millisecond values:

DelayMilliseconds
Now0
2 hours7200000
12 hours43200000
24 hours86400000
48 hours172800000

Verify access and inspect the chosen live contract

Preview requires read access. Activation and custom campaign mutations require a paid workspace, linkedin:write, and a connected LinkedIn account. For the standard flow inspect:

wannalead endpoints automation.campaigns.preview --examples --json-schema
wannalead endpoints automation.campaigns.activate --examples --json-schema

For a custom graph inspect at least:

wannalead me
wannalead endpoints automation.campaigns.create --examples --json-schema
wannalead endpoints automation.campaigns.sequences.create --examples --json-schema
wannalead endpoints automation.campaigns.reviews --examples --json-schema

Also inspect every additional endpoint immediately before first use. On linkedin_connection_required, ask the user to run wannalead auth connect. On campaigns_not_in_trial, explain that campaign automation is unavailable on the trial. Never attempt to change billing or permissions.

Sending window

A campaign sends at any hour unless it has a schedule_policy. To restrict visible actions (invitations, messages, follow-ups, likes, comments) to the user's hours, pass schedule_policy to the standard preview/activation or to automation.campaigns.create, or set it later with automation.campaigns.update (also on a running campaign):

wannalead call automation.campaigns.update -param campaign_id=<campaign_id> \
  -idempotency-key <stable-key> \
  -body '{"schedule_policy":{"timezone":"Europe/Paris","weekdays":[1,2,3,4,5],"start_time":"09:00","end_time":"18:00"}}'
  • timezone is required (IANA name). weekdays uses 0 = Sunday to 6 = Saturday and defaults to every day. start_time/end_time are HH:MM (end_time up to 24:00) and default to the whole day.
  • An action that comes due outside the window waits for the next opening; it keeps its frozen copy and does not spend a retry. Relationship checks and acceptance detection keep running, so a connection accepted at night gets its message at the opening.
  • Delays still apply: a message due 2 hours after an acceptance at 17:30 waits until the next opening.
  • The window uses one time zone per campaign, not each recipient's. When recipients sit in different time zones and the user wants local business hours, group them into one campaign per time zone (use the location from their enriched profiles) and set each campaign's timezone accordingly; confirm the split with the user.
  • "schedule_policy": null removes the window. automation.campaigns.get returns the active window as schedule_policy (or null).
  • Confirm the window with the user before launch, like any other timing.

Reuse a compatible campaign before creating one

Before previewing or creating a new campaign, list the workspace campaigns and inspect plausible matches with automation.campaigns.get, automation.campaigns.sequences.list, and automation.campaigns.targets.list. Prefer extending an existing campaign when all of the following hold:

  • its intake_state is open, and its status is running or a compatible draft that is already intended for the same work;
  • its sender, objective, audience, and operational purpose fit the new targets;
  • its active sequence has the requested timing, branches, and message steps;
  • the new targets are not already present in that campaign.

Do not infer sequence compatibility from the campaign name, active version, or root step alone. Reuse only when the exact active step graph is known from the current workflow or exposed by current public reads. If the public contract does not expose enough detail to verify it, treat compatibility as unknown.

Do not reuse a canary, E2E, or unrelated one-off or migration campaign merely to reduce the campaign count. A paused campaign requires its explicit resume flow; do not reuse completed, archived, or canceled campaigns. If no compatible campaign exists, create a new one and briefly state why.

Add targets to a compatible campaign through automation.campaigns.imports.stage followed by automation.campaigns.imports.commit. The commit binds new targets to the campaign's active sequence version and root step. Then create and freeze their per-target drafts and review/schedule those target IDs; do not launch an already-running campaign again.

If reuse would require publishing a different active sequence, state the impact and obtain explicit approval before changing it. Existing scheduled targets retain their assigned sequence version; newly committed targets use the active version at commit time.

To change only timing on a running campaign (a step delay_ms or a branch delayMs, for example the delay between acceptance and the first message), patch the active version in place with automation.campaigns.sequences.update and the same steps. Every target, including those already invited, uses the new delay at its next transition. Do not publish a new version for a timing change: that would require unscheduling and rescheduling every target.

An existing LinkedIn invitation cannot be attached to a campaign by its invitation URN. For already-pending invitations, use a bounded relationship.check chain that routes relationship.pending to a later check and relationship.first_degree to the approved message. Omit any relationship.not_connected to invitations.send branch unless the user has explicitly approved sending a replacement invitation.

Personalize before launch

For each recipient:

  1. Use profiles.enrich for current role and company. Use profiles.posts or another relevant public Wannalead read when it supplies evidence for the requested angle.
  2. Draft one message from verified recipient context and the user's angle. Do not assert a pain point, familiarity, or intent that the evidence does not support. Do not reuse the same body with only the name changed.
  3. Apply the installed humanizer skill. This is required before approval.
  4. Show the user the recipient, evidence, angle, and exact final message. Get explicit approval of the complete recipient-to-message mapping and campaign timing. A material rewrite requires new approval.

The campaign invitation is sent without a note. The personalized text belongs to the message step after acceptance, not to the invitation.

Standard two-call workflow

When no compatible campaign exists and the requested sequence matches the standard preset, preview it without side effects:

{
  "name": "Paris architects",
  "acceptance_window_days": 30,
  "first_message_delay_hours": 24,
  "follow_up_delay_days": 4,
  "schedule_policy": {"timezone": "Europe/Paris", "weekdays": [1, 2, 3, 4, 5], "start_time": "09:00", "end_time": "18:00"},
  "targets": [
    {
      "public_identifier": "alice",
      "first_message": "<approved first message>",
      "follow_up": "<approved follow-up>"
    }
  ]
}
wannalead call automation.campaigns.preview -body '<campaign-json>'

Show the returned recipients, exclusions, exact messages, and timing. After exact approval, repeat the unchanged campaign fields with the returned token:

wannalead call automation.campaigns.activate \
  -idempotency-key <stable-campaign-key> \
  -body '<same-campaign-json-plus-preview_token-and-confirm-true>'

Activation requires linkedin:write, preview_token, confirm: true, and a stable idempotency key. Do not report success until it returns running and every eligible target is scheduled.

Custom campaign builder

Use the granular sections below when extending a compatible campaign, when the user requests a custom graph, or when the live catalog does not expose both standard endpoints.

Create or extend the campaign

Every mutation needs a unique, stable idempotency key. Reuse a key only to replay the identical operation and body.

When no compatible campaign exists, create a campaign shell with the approved recipients:

wannalead call automation.campaigns.create \
  -idempotency-key <campaign-create-key> \
  -body '{"name":"<campaign-name>","targets":[{"profile_url":"<profile-url-1>"},{"profile_url":"<profile-url-2>"}]}'

When extending an existing campaign, or importing a larger list, use automation.campaigns.imports.stage followed by automation.campaigns.imports.commit; do not skip the commit. Then list the targets to obtain their stable target IDs:

wannalead call automation.campaigns.targets.list \
  -param campaign_id=<campaign-id>

Publish the sequence

Number steps from 0. The step named by root_step_key must have order: 0 and delay_ms: 0; the server rejects anything else with root_step_order_not_zero or root_step_delay_not_zero.

For an invitation-only campaign, publish invitations.send directly as the root. The server reuses a cached stable identity when available, resolves a missing identity as an internal prerequisite, and always reruns the fresh profile.actions safety check immediately before dispatch. First-degree, pending, or unavailable targets terminate as non-billable skips.

{
  "source": "manual_edit",
  "root_step_key": "invite",
  "publish": true,
  "steps": [
    {
      "step_key": "invite",
      "type": "invitations.send",
      "order": 0,
      "delay_ms": 0,
      "endpoint_key": "invitations.send",
      "review_policy": "required"
    }
  ]
}

For a campaign that should message existing first-degree connections without inviting anyone, make relationship.check the root and route only relationship.first_degree to the message. A target that is not currently a first-degree connection has no matching branch and completes without an invitation or message.

Inbound invitations are handled by the engine, not by the graph: when a relationship.check, an invitations.send preflight, or a messages.send_profile preflight sees that the target already invited the account, the worker accepts that invitation and emits relationship.first_degree. Do not add a relationship.invitation_received branch unless the user wants a manual fallback for the rare case where the accept itself fails (the event only surfaces then).

{
  "source": "manual_edit",
  "root_step_key": "relationship",
  "publish": true,
  "steps": [
    {
      "step_key": "relationship",
      "type": "relationship.check",
      "order": 0,
      "delay_ms": 0,
      "endpoint_key": "profile.actions",
      "review_policy": "none",
      "branch_edges": {
        "relationship.first_degree": {
          "stepKey": "first_message",
          "delayMs": 0
        }
      }
    },
    {
      "step_key": "first_message",
      "type": "messages.send_profile",
      "order": 1,
      "delay_ms": 0,
      "endpoint_key": "messages.send_profile",
      "review_policy": "required"
    }
  ]
}

For a mixed audience, start with relationship.check, route relationship.first_degree to the message and relationship.not_connected to invitations.send. Give the invitation an invitation.sent branch to a separate profile.actions acceptance check, then route that check's relationship.first_degree outcome to the same message. This prevents duplicate invitations while still allowing new connections to receive the approved message after acceptance.

When the campaign must message a target after acceptance, add an invitation.sent branch from invite to a profile.actions acceptance check, then branch relationship.first_degree to the approved message after the chosen delay. Acceptance is observed asynchronously, so that delay is measured from LinkedIn's connection timestamp when available on mirror_v1 campaigns, otherwise from the observation time. A catch-up can therefore make a message due immediately. Read acceptance_detection from automation.campaigns.get; existing campaigns remain on legacy_poll.

Prefer the standard two-call workflow for invitation → message → follow-up. When a custom graph is required, chain every step from the root: the engine follows branch_edges only, never step order, so a step without an incoming edge never runs and the target completes at the last reached step. Publishing rejects such graphs with branch_edges_unreachable_step. The complete invitation → acceptance check → message (2 h after acceptance) → follow-up (4 days later) graph is:

{
  "root_step_key": "invite",
  "publish": true,
  "steps": [
    {
      "step_key": "invite",
      "type": "invitations.send",
      "order": 0,
      "delay_ms": 0,
      "branch_edges": {
        "invitation.sent": { "stepKey": "acceptance_check", "delayMs": 0 }
      }
    },
    {
      "step_key": "acceptance_check",
      "type": "relationship.check",
      "endpoint_key": "profile.actions",
      "order": 1,
      "delay_ms": 0,
      "branch_edges": {
        "relationship.first_degree": { "stepKey": "first_message", "delayMs": 7200000 }
      }
    },
    {
      "step_key": "first_message",
      "type": "messages.send_profile",
      "endpoint_key": "messages.send_profile",
      "order": 2,
      "delay_ms": 0,
      "review_policy": "required",
      "branch_edges": {
        "message.sent": { "stepKey": "follow_up", "delayMs": 345600000 }
      }
    },
    {
      "step_key": "follow_up",
      "type": "messages.send",
      "endpoint_key": "messages.send",
      "order": 3,
      "delay_ms": 0,
      "review_policy": "required"
    }
  ]
}

Every follow-up stops when the prospect has replied. The server treats any message step reached from an earlier sent message as a follow-up, even through intermediate relationship.check steps. Before dispatching it, the server re-reads the conversation and disarms the step (follow_up_reply_observed) if the prospect replied. A relationship.check between two messages is optional: messages.send_profile already refuses to send unless the latest observed relationship is first-degree, so the extra step only adds a read. When reporting on a campaign, say a follow-up was skipped because of a reply; never tell the user a reply-stopped prospect was "relanced". If a relance reaches someone who had already replied, treat it as a bug and report it: the job's followUpSourceJobId should point to the first message.

Before asking the user to approve a mirror_v1 campaign launch, state: "This campaign automatically checks your recent connections for invitation acceptances, even if you haven't enabled the full LinkedIn mirror. It stops when there are no invitations left to track."

The provisional healthy-account target is p95 detection within 25 minutes (15-minute head reads plus propagation), subject to the canary gates. Do not present it as a measured guarantee until those gates pass. Offline time and LinkedIn cooldowns delay detection. Stale reads or a disabled mirror switch use targeted polling; the normal 72-hour safety check is shared with sequence checks. Invitation-only campaigns collect acceptance metrics without targeted safety reads in normal operation. Tracking lasts 31 days after sending; acceptances beyond that window do not trigger a message. Already-pending targets at launch retain their existing sequence checks.

Add a visible profile.full_unary step only when the user explicitly requests a profile visit or a delay anchored to that visit. Keep the longer visible profile.full_unary -> profile.actions -> invitations.send graph only when the workflow itself needs to route existing first-degree connections to a separate branch. Do not add these reads merely to make an invitation safe; the server owns identity resolution and the just-in-time relationship preflight.

The outer request accepts snake_case, but each object inside branch_edges uses stepKey and delayMs in camelCase. Pass timing values as JSON numbers. Create and publish the sequence with:

wannalead call automation.campaigns.sequences.create \
  -param campaign_id=<campaign-id> \
  -idempotency-key <sequence-create-key> \
  -body '<sequence-json>'

Freeze approved messages when the sequence sends messages

Skip this section for invitation-only campaigns. When the active sequence includes first_message, optionally persist the facts and personalization rationale with automation.targets.context. Then create and approve a message draft for every target using the exact user-approved text:

wannalead call automation.message-drafts.create \
  -idempotency-key <draft-create-key> \
  -body '{"campaign_id":"<campaign-id>","target_id":"<target-id>","step_key":"first_message","proposed_text":"<approved-message>"}'

wannalead call automation.message-drafts.approve \
  -param draft_id=<draft-id> \
  -idempotency-key <draft-approve-key> \
  -body '{"edited_text":"<same-approved-message>"}'

Do not approve a generated draft before comparing it byte-for-byte with the text the user approved.

Voice message steps

A first_dm or follow_up message step can send a LinkedIn voice message instead of text. The user supplies the audio file; Wannalead does not record, synthesize, or convert audio. The file must already be AAC in an MP4/M4A container (audio/mp4), up to 20 MiB, audio only. Any other format is rejected with 415 and the error names the expected format; tell the user and suggest ffmpeg -i input -c:a aac -b:a 32k -ac 1 voice.m4a instead of converting silently.

Upload the file once, then create a voice variant for the step. A voice variant has no template_text, uses llm_mode none, and cannot be a holdout or an invitation_note:

wannalead media voice-upload --file voice.m4a

wannalead call automation.campaigns.message-variants \
  -param campaign_id=<campaign-id> \
  -idempotency-key <variant-key> \
  -body '{"operation":"create","step_key":"first_message","channel":"first_dm","variant_key":"voice","weight":1,"voice_media_id":"<vm_id>","review_policy":"required","llm_mode":"none"}'

Create each target's draft without proposed_text and approve it without edited_text; a voice draft cannot be edited. The same audio goes to every target of that variant, so confirm with the user that one recording fits all of them.

Validate, launch, and schedule

Validate while the campaign is still a draft. Resolve every blocking issue before launch and report warnings to the user:

wannalead call automation.campaigns.validate \
  -param campaign_id=<campaign-id> \
  -idempotency-key <validation-key> \
  -body '{}'

Immediately before launch, restate the campaign name, exact recipients, timings, and exact messages. Launch only after explicit user intent:

wannalead call automation.campaigns.launch \
  -param campaign_id=<campaign-id> \
  -idempotency-key <launch-key> \
  -body '{}'

Launch changes the campaign to running, but it does not approve or schedule the targets. Schedule the approved target IDs against the published sequence:

wannalead call automation.campaigns.reviews \
  -param campaign_id=<campaign-id> \
  -idempotency-key <review-and-schedule-key> \
  -body '{"decision":"approve","target_ids":["<target-id-1>","<target-id-2>"],"sequence_version":<version>,"schedule":true}'

Use not_before_at in epoch milliseconds when the whole selected target set must not start before an absolute time. More than 100 targets require the confirmation-token flow returned by the review endpoint.

A large schedule answers within about 40 seconds. When the schedule result has complete: false, resend the same request (same body and idempotency key) until pending_target_ids is empty; targets already scheduled are skipped.

Verify and monitor

Do not report success from launch alone. Confirm both running status and scheduled targets, then use these read endpoints for follow-up:

wannalead call automation.campaigns.get -param campaign_id=<campaign-id>
wannalead call automation.campaigns.summary -param campaign_id=<campaign-id>
wannalead call automation.campaigns.targets.list -param campaign_id=<campaign-id>
wannalead call automation.campaigns.activities.list -param campaign_id=<campaign-id>

Report per-target progress using product states and activity events. A future scheduled time is normal waiting, not a failure. Do not manually retry a pending step or create a replacement campaign.

automation.campaigns.get maps to GET /v1/linkedin/automation/campaigns/{campaign_id}.

For lifecycle changes, inspect and use the public endpoint matching the user's explicit request:

  • Campaign: automation.campaigns.pause, resume-preview, resume, cancel, or archive. A paused campaign resumes through preview and confirmation, not by calling launch again. There is no campaign-level stop: use cancel for the campaign or automation.targets.stop for one target.
  • Target: automation.targets.pause, resume, stop, skip-next, opt-out, unreview, unschedule, or delete.

Boundaries

  • Never expose or depend on infrastructure, workers, browser routing, cookies, private endpoints, operational local files, or direct LinkedIn calls. The five files defined by wannalead-onboarding are the only local context this workflow may use.
  • Never change billing, permissions, account binding, or connection state to make a campaign pass validation.
  • Stop on authentication, connection, billing, rate-limit, restriction, or idempotency-conflict errors. Preserve returned request_id, campaign_id, target_id, and job_id values for safe continuation.
  • Never claim that an invitation, acceptance, or message occurred until the campaign activity confirms it.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/wannalead.co/campaign-automation">View campaign-automation on skillZs</a>