Actions: email, sequences, CRM and notifications

External write. Creates or updates the HubSpot contact of each workspace contact, matched by email (a contact without one is skipped NO_EMAIL). Sends email, first and last name, job title, company, phone, LinkedIn URL and city (input.fields narrows it). Conflict policy: never a blind create, the record is looked up first; an existing record gets only its empty fields filled (a different CRM value is kept and counted as a conflict) unless input.onConflict is overwrite; an empty value is never sent, so nothing is ever cleared or deleted. Several matching records fail the target CRM_DUPLICATE_RECORDS and nothing is written. Uses the workspace's own HubSpot connection only (none: 422 CRM_NOT_CONNECTED, also on a dry run); free (CRM writes are 0 credits). Always async and reviewed by default: the action is created pending_approval (the workspace default; always for onConflict: overwrite, the dashboard agent and MCP, whatever the key's mode) with each target's write frozen and the current HubSpot values shown next to the new ones; a person approves it in the app, then it runs. Right before each write the write is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. A record is created at most once per action, even when the target is run again; a create refused 409 (made meanwhile) is filled instead. Target outcomes: succeeded with {hubspotId, action: created|updated|unchanged, written, kept, conflicts}, or CRM_AUTH (after one token refresh), CRM_REFUSED, CRM_OUTCOME_UNKNOWN (a create that may have happened: never retried blindly), UPSTREAM_UNAVAILABLE (failed before any write, retried). dryRun: true reads HubSpot for the first 10 targets in parallel (40 s budget, no write) and returns writes.crm counts and, for the first 5, the per-field diff (set, fill, same, keep, overwrite).

External write. Creates or updates the HubSpot company of each workspace contact's company, matched by its domain (a contact without one is skipped NO_DOMAIN). Sends the domain and the company name. One write per domain: other contacts of the same company are skipped DUPLICATE_DOMAIN and listed in the written target's contactIds. Conflict policy: never a blind create, the record is looked up first; an existing record gets only its empty fields filled (a different CRM value is kept and counted as a conflict) unless input.onConflict is overwrite; an empty value is never sent, so nothing is ever cleared or deleted. Several matching records fail the target CRM_DUPLICATE_RECORDS and nothing is written. Uses the workspace's own HubSpot connection only (none: 422 CRM_NOT_CONNECTED, also on a dry run); free (CRM writes are 0 credits). Always async and reviewed by default: the action is created pending_approval (the workspace default; always for onConflict: overwrite, the dashboard agent and MCP, whatever the key's mode) with each target's write frozen and the current HubSpot values shown next to the new ones; a person approves it in the app, then it runs. Right before each write the write is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. A record is created at most once per action, even when the target is run again; a create refused 409 (made meanwhile) is filled instead. Target outcomes: succeeded with {hubspotId, action: created|updated|unchanged, written, kept, conflicts}, or CRM_AUTH (after one token refresh), CRM_REFUSED, CRM_OUTCOME_UNKNOWN (a create that may have happened: never retried blindly), UPSTREAM_UNAVAILABLE (failed before any write, retried). dryRun: true reads HubSpot for the first 10 targets in parallel (40 s budget, no write) and returns writes.crm counts and, for the first 5, the per-field diff (set, fill, same, keep, overwrite).

Send. Enrolls each contact in a HubSpot sequence (HubSpot then emails them from the sender's mailbox). The contact is found in HubSpot by its email (no HubSpot contact: skipped CRM_CONTACT_NOT_FOUND; run crm.hubspot.upsert_contact first). A contact HubSpot already has in a sequence (enrolled by a play, in HubSpot or by another tool) is skipped ALREADY_ENROLLED, read before anything is claimed and again from HubSpot's answer. Uses the workspace's own HubSpot connection only (none: 422 CRM_NOT_CONNECTED). Class send, async, identity required (the key's bound identity, else identityId): a person is sent this at most once per identity within 30 days, whatever the path, retry or content. Reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with each target's content frozen; a person approves it in the app, then it runs. Each target passes the send gate first (suppressed, excluded, unsubscribed or bounced contacts, an active sequence, an earlier send, the principal's daily sends; a contact edited since the approval is CONTENT_CHANGED). An answer that may mean sent (timeout, 5xx) ends OUTCOME_UNKNOWN and is never sent again. 6 credits (connector.outreach.send) per confirmed send; anything else is free.

Send. Emails each contact through a one-lead EmailBison campaign (the subject and body are templates filled from the stored contact: {{firstName}}, {{company}}, ...; a missing field is skipped MISSING_TEMPLATE_VARIABLES). Only the campaign start sends: a failure while building the campaign sends nothing (NOT_SENT). Uses the workspace's own EmailBison connection only (none: 422 CRM_NOT_CONNECTED). Class send, async, identity required (the key's bound identity, else identityId): a person is sent this at most once per identity within 30 days, whatever the path, retry or content. Reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with each target's content frozen; a person approves it in the app, then it runs. Each target passes the send gate first (suppressed, excluded, unsubscribed or bounced contacts, an active sequence, an earlier send, the principal's daily sends; a contact edited since the approval is CONTENT_CHANGED). An answer that may mean sent (timeout, 5xx) ends OUTCOME_UNKNOWN and is never sent again. 6 credits (connector.outreach.send) per confirmed send; anything else is free.

External write. Sends one HTTP request per workspace contact to the caller's own endpoint. method is GET, POST, PUT or PATCH (no DELETE). The URL must be https without credentials in it; every address it resolves to, and every redirect hop, is checked when the request is made (private, loopback, link-local and metadata addresses are refused, also after a redirect or a DNS change), and the target fails URL_BLOCKED or REDIRECT_BLOCKED. {{contact.field}} in the URL, header values and body strings is filled from the stored contact. Headers: only Content-Type, Accept, User-Agent and custom X-* (not forwarding or credential-like ones; anything else is 400). Credentials come only from an http_auth connector (auth.connectorId: a credential, the exact hosts it may go to, its header and scheme); any other connector is 422 CONNECTOR_NOT_ALLOWED, a URL off its hosts (or with a template before the path) 422 HOST_NOT_ALLOWED. The credential is added when the request is made, dropped on a redirect to another origin, and never stored, shown in the plan or the approval, or returned (a response echoing it, raw, URL-encoded or base64, is redacted). Caps: request body 64 KB (BODY_TOO_LARGE), 20 headers, 10 s per request (HTTP_TIMEOUT), response read up to 256 KB with the first 4,000 characters in the result. 8 credits (api.webhook.call) per request answered 2xx; any other answer fails the target HTTP_<status> and is free. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's whole request frozen; a person approves it in the app, then it runs. Right before each request it is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Each target's request is sent at most once; a target run again after its request may have left fails HTTP_OUTCOME_UNKNOWN, never sends twice. dryRun: true sends nothing and returns the first 5 requests (no secret) with their URL checks.

Send. One email per contact, from the identity's own connected mailbox (the connected Gmail or Outlook account sequences send from; exactly one active mailbox, else 403 IDENTITY_UNAVAILABLE), to each target contact's stored address (none: skipped NO_EMAIL). subject (at most 200 characters once filled) and body (at most 50,000) are templates: {{firstName}}, {{lastName}}, {{company}}, {{title}}, ... are filled from the stored contact; a target missing a field is skipped MISSING_TEMPLATE_VARIABLES. isHtml: true sends the body as HTML. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's rendered content frozen; a person approves it in the app, then it runs. Right before each send the content is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). A person whose email bounced is skipped BOUNCED. Never twice on this channel: a person this identity already emailed within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it: Owlbound's send log on the identity's mailboxes (sequences, plays, the inbox and the API write it before and after each request), sequence emails sent from the workspace sender, the person's synced email conversations (outbound messages, including ones sent from the mailbox itself), EmailBison emails and succeeded API actions; checked again right before the request, once the mailbox is free. The identity's daily email limit and health apply as for sequences; a send that must wait is scheduled and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.email.send) per email sent.

Send. One WhatsApp message per contact (at most 4,096 characters once filled), from the identity's own connected WhatsApp account (none: 403 IDENTITY_UNAVAILABLE), to each target contact's stored phone number (none or unusable: skipped NO_PHONE). {{firstName}}, {{company}}, ... are filled from the stored contact; a target missing a field is skipped MISSING_TEMPLATE_VARIABLES. No media in this version. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's rendered content frozen; a person approves it in the app, then it runs. Right before each send the content is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice on this channel: a person this identity already sent a WhatsApp message within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED): Owlbound's send log on the identity's WhatsApp account, the person's synced WhatsApp conversations and succeeded API actions; checked again right before the request. The account's WhatsApp limit (50 a day) and health apply; a send that must wait is scheduled and runs later. A send whose outcome is unknown fails OUTCOME_UNKNOWN for a person to check; it is never retried. 6 credits (connector.outreach.send) per message sent.

External write. One message per target contact in channelId of the workspace's own Slack connection: a Slack connector (connectorId, else the workspace's Slack app install; none: 422 NOTIFY_NOT_CONNECTED). text is a template filled from the stored contact ({{firstName}}, {{company}}, ...; a missing field is skipped MISSING_TEMPLATE_VARIABLES); blocks (Block Kit, at most 50, sent as given) and threadTs (reply in a thread) are optional. A refusal by Slack fails the target SLACK_<ERROR> (e.g. SLACK_CHANNEL_NOT_FOUND, SLACK_NOT_IN_CHANNEL). Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's message frozen; a person approves it in the app, then it runs. Right before each post the message is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Each target is posted at most once: a target run again after its post may have left, or a post whose outcome is unknown (timeout, network), fails NOTIFY_OUTCOME_UNKNOWN and is never posted twice. No person outside the workspace is contacted, so no send limit applies. Free (connector.notification.send).

External write. One message per target contact through the workspace's Google Chat connector (connectorId; another kind is 422 CONNECTOR_NOT_ALLOWED): to space (spaces/..., through the Chat API with the connector's OAuth token), else to the connector's incoming webhook, else to its space. Webhook URLs and tokens stay on the connector; they are never taken from the request. text is a template filled from the stored contact (at most 4,096 characters; a missing field is skipped MISSING_TEMPLATE_VARIABLES); threadKey threads the messages. A refusal by Google fails the target GOOGLE_CHAT_<status>. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's message frozen; a person approves it in the app, then it runs. Right before each post the message is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Each target is posted at most once: a target run again after its post may have left, or a post whose outcome is unknown (timeout, network), fails NOTIFY_OUTCOME_UNKNOWN and is never posted twice. No person outside the workspace is contacted, so no send limit applies. Free (connector.notification.send).

Send class: an enrollment starts outreach to a real person. Enrolls each contact (or each table row's linked contact) into input.sequenceId through the app's enrollment (the same guards as the app and v0 /sequences/{id}/enroll; never forced). The sequence sends as its assigned identity: a key bound to another identity is 403 IDENTITY_NOT_ALLOWED, a sequence without one 422 IDENTITY_REQUIRED, a paused one 422 SEQUENCE_INACTIVE, one without steps 422 SEQUENCE_NO_STEPS, another workspace's 404. Skipped targets (dry run and run): SUPPRESSED (archived or opted out), UNSUBSCRIBED, BOUNCED (email sequences), EXCLUDED (exclusion lists), MISSING_CHANNEL (no email or LinkedIn URL a step needs), ALREADY_ENROLLED (in flight in this sequence, or enrolled by the API in the last 30 days), IN_SEQUENCE (active in another sequence), NO_CONTACT (a row without a linked contact). Always async and reviewed by default: the action is created pending_approval (the workspace default; always for the dashboard agent and MCP, whatever the key's mode) with each target frozen (sequence, identity, contact); the identity's owner (or a person they delegated approvals to) approves it in the app, then it runs. A target is enrolled at most once, even when run again; a sequence moved to another identity since the approval is skipped CONTENT_CHANGED. The messages are then sent by the sequence, with its own limits, working hours and guards. Each enrolled contact spends one of the key's daily sends (caps.dailySends; over it the target is scheduled with reason KEY_DAILY_SENDS until the next UTC day, then enrolled; past 6 days from the action's creation it is skipped KEY_DAILY_SENDS; nothing is charged while it waits). 4 credits (sequence.enrollment) per enrolled contact, charged on success only. dryRun: true returns who would be enrolled and who skipped, and enrolls nothing.

Per contact (or table row's linked contact), its enrollment in input.sequenceId (a sequence of this workspace; another's is 404; a key bound to an identity may only change that identity's sequences, else 403 IDENTITY_NOT_ALLOWED). An active or waiting enrollment is paused by hand (it stays paused when the sequence is resumed); otherwise skipped NOT_ENROLLED or NOT_ACTIVE. Write class, scope act, free, no approval; inline for one contact. dryRun: true changes nothing.

Per contact (or table row's linked contact), its enrollment in input.sequenceId (a sequence of this workspace; another's is 404; a key bound to an identity may only change that identity's sequences, else 403 IDENTITY_NOT_ALLOWED). An active, waiting or paused enrollment ends as completed (a stop never starts a chained sequence and marks nothing unsubscribed; nothing is deleted); otherwise skipped NOT_ENROLLED or ALREADY_ENDED. Write class, scope act, free, no approval; inline for one contact.

Per contact (or table row's linked contact), its enrollment in input.sequenceId (a sequence of this workspace; another's is 404; a key bound to an identity may only change that identity's sequences, else 403 IDENTITY_NOT_ALLOWED). Send class: resuming restarts outreach. Reviewed like an enrollment (the sequence's identity's owner approves it in the app; always for the dashboard agent and MCP); each target frozen (sequence, identity, contact, enrollment). Right before resuming, the enrollment must still be paused, the sequence active under the same identity, and the contact still contactable (SUPPRESSED, UNSUBSCRIBED, EXCLUDED keep it paused). Skipped: NOT_ENROLLED, NOT_PAUSED. A paused sequence is 422 SEQUENCE_INACTIVE. Free; the sequence's own steps, limits and guards apply to what it then sends.

Send class: a play can contact people. Starts the play's deployed version (never the draft) for each contact (or each table row's linked contact), as the app's manual start does; its nodes then run in the play executor, every send through the send gate (contact rules, limits, the identity's counters), and its own Human review nodes still apply. A play that is not deployed is 422 PLAY_NOT_DEPLOYED, a paused one 422 PLAY_INACTIVE, one whose cost has no bound (a list loop without Max items, or a cycle) 422 PLAY_COST_UNBOUNDED, another workspace's 404. A play with nodes that contact people (LinkedIn, email, sequence enrollment) runs as one identity (the key's bound identity, or identityId): its LinkedIn nodes send through that identity's account, and its sequence nodes must enroll into that identity's sequences (403 IDENTITY_NOT_ALLOWED). Skipped targets (dry run and run): SUPPRESSED, UNSUBSCRIBED, BOUNCED, EXCLUDED (plays that contact people), ARCHIVED, ALREADY_ENROLLED (in flight in this play), REENROLLMENT_NOT_ALLOWED, ALREADY_TRIGGERED (started on this play version by the API in the last 30 days), NO_CONTACT. Always async; the approval follows what the play can do: a play that contacts people is reviewed like any send (the workspace default; always for the dashboard agent and MCP), one that writes to an outside system (CRM, HTTP, Slack) like an external write, any other only over the key's credit threshold. Each target is frozen (play, deployed version, contact, identity): a play redeployed since the approval is skipped CONTENT_CHANGED. A contact is started at most once per play version, even when run again. Credits: each started contact holds the play's maximum path cost (every node at its price, the costliest branch, loops at their Max items), counted against maxCredits, the key's caps.dailyCredits and the wallet (skipped with RUN_CAPPED, CAP_EXCEEDED or INSUFFICIENT_CREDITS otherwise); the nodes are charged their usual prices from that hold, a node that would go past it stops the run RUN_CAPPED, and what is left is released when the run ends. Starting a play that contacts people spends one of the key's daily sends (caps.dailySends). dryRun: true returns the version, the per-contact maximum and who would be started, and starts nothing.