--- title: "Rewrite a pending task's message" method: POST path: "/outreach-tasks/{task_id}/edit/" tags: ["outreach"] --- # Rewrite a pending task's message `POST /outreach-tasks/{task_id}/edit/` ## Request - Base URL: `https://api.getoneprofile.ai` (the document declares no server; this is the origin it was published from) - URL: `https://api.getoneprofile.ai/outreach-tasks/{task_id}/edit/` - Auth: one of: - API key in header `X-API-Key` - HTTP bearer Change what a pending task will send before approving it. An email's rewrite is stored as the contact's message override; a LinkedIn note or message is kept on the task as typed, and clipped to LinkedIn's ceilings when the approved step is queued, the way the step's own render would be. Only while the task is pending: once the channel has it, the text a person saw is the text that sends. ## Path parameters - `task_id` string, uuid, required ## Request body - OutreachTaskEditSchema: Rewrite what a pending task will send. ``subject`` left out keeps the subject the task already carries; an explicit null clears it, which for an email means the follow-up lands in-thread. The two are told apart on the wire so a client fixing a typo in the body cannot silently strip a first email's subject. - `body` string, required - `subject` string, nullable ## Response `200` Successful Response - OutreachTaskReadSchema: One row of the approval queue, every name the page shows resolved server-side. The task table stores ids; the page shows names. The sequence, the step, the sender and the deciding person are all resolved here rather than by the client, so no raw actor id ever crosses the wire and a sequence or sender since deleted reads as a blank rather than a broken lookup. - `approved_at` string, date-time, nullable, required - `approved_by_display_name` string, nullable, required: Who approved it, as a name. Null when nobody has, or the person could not be resolved. - `ask_reason` 'low_confidence' | 'findings' | 'insufficient_data' | 'policy' | 'always_ask' | 'sequence_manual' | 'step_requires_approval' | 'daily_cap' | 'unverified_sender' | 'suppressed' | 'different_sender' | 'label' | 'question' | 'consecutive_cap' | 'thread_cap' | 'hourly_cap' | 'org_daily_cap' | 'stale_inbound' | 'sequence_gone' | 'bot_question' | 'automated_counterparty' | 'kill_switch' | 'authentication' | 'language' | 'linkedin_only' | 'send_interrupted' | 'sender_switched_to_manual', required: Why a message that could have sent unattended was put in front of a person. One vocabulary for every gate between an agent writing a message and the message leaving: what the agent itself said about the draft (``LOW_CONFIDENCE``, ``FINDINGS``, ``INSUFFICIENT_DATA``, ``POLICY``), what the sender or the cadence asked for (``ALWAYS_ASK``, ``SEQUENCE_MANUAL``, ``STEP_REQUIRES_APPROVAL``), what the pacing rules refused (``DAILY_CAP``, ``CONSECUTIVE_CAP``, ``THREAD_CAP``, ``HOURLY_CAP``, ``ORG_DAILY_CAP``), what the mailbox or the thread made unsafe (``UNVERIFIED_SENDER``, ``DIFFERENT_SENDER``, ``LABEL``, ``QUESTION``, ``STALE_INBOUND``, ``SEQUENCE_GONE``), and what the counterparty turned out to be (``BOT_QUESTION``, ``AUTOMATED_COUNTERPARTY``, ``AUTHENTICATION``, ``LANGUAGE``, ``LINKEDIN_ONLY``). ``KILL_SWITCH`` is the platform switch that stops unattended sending outright, and ``SEND_INTERRUPTED`` an unattended reply whose send never got as far as a provider. ``SENDER_SWITCHED_TO_MANUAL`` is a LinkedIn step queued unasked that went back to a person because its sender switched to manual before it ran. Stored on the task so the queue can say why each row is there, and so "why did nothing send" is answerable by counting rows rather than by reading logs. - `body` string, nullable, required: The rendered message as it will send: an email body, a note, a LinkedIn message. - `channel` 'linkedin' | 'email', required: Which channel performs the task once it is allowed to run. - `confidence` string, nullable, required: How sure the agent was that its message could go out unedited: `high` (a person could send it unread), `medium` (worth a glance) or `low` (needs work). Null when no agent wrote the message. - `confidence_score` integer, nullable, required: The number behind `confidence`: the agent's own score for its message, from 0 to 100. Read from the agent's message as it stands now. Null when no agent wrote the message, or the agent gave no score. - `contact_company` string, nullable: The contact's company, from whichever column of the audience table holds it ('Company', 'Company Name', 'Organization' and the like). Null when the table has none or leaves it blank. - `contact_fields` OutreachTaskContactFieldSchema[]: Every filled column of the contact's audience row, in the table's order. Empty for housekeeping work and for a row since deleted. - `name` string, required: The column's header, as the table names it. - `value` string, required: What the row holds there, as text; long values are cut. - `contact_identity` string, nullable: The address, profile slug or number behind the label, so a row can show the name and still say who that is. Equal to the label where no name was found; null for housekeeping. - `contact_label` string, nullable, required: The contact as the queue names them: a name, else an address or a profile URL. - `contact_title` string, nullable: The contact's job title, from whichever column of the audience table holds it ('Job Title', 'Title', 'Position' and the like). Null when the table has none or leaves it blank. - `created_at` string, date-time, required - `due_at` string, date-time, required: When the channel would run it if nobody were in the way. - `editable` boolean, required: Whether the queue may rewrite the message before approving: pending, and a kind that carries text. - `enrolment_id` string, uuid, nullable, required - `flagged` boolean, required: Whether a check found a problem in the agent's message (any finding at warning strength), whatever `ask_reason` says: a task held for a setting can still carry a message with a placeholder that never filled in. False when no agent wrote the message. - `id` string, uuid, required - `kind` string, required: The LinkedIn action kind slug or `email`. - `linkedin_action_id` string, uuid, nullable, required - `note` string, nullable, required: What the person wrote when settling it: why they rejected it. - `outbound_message_id` string, uuid, nullable, required: The message the Outbound Agent wrote for this task. Null when a person wrote the words, and on a LinkedIn step that carries no message. - `outcome` string, nullable, required: How it ended: the channel's own terminal word. - `progress` OutreachTaskProgressReadSchema: Where an approved, finished or failed task's work stands, read from its channel. - `error_code` string, nullable, required: Why a failed LinkedIn step failed, as the channel's error code; null otherwise. - `error_message` string, nullable, required: Why it failed, as a sentence from the channel or the send engine; null otherwise. - `hold` 'sequence_paused' | 'contact_paused': Why a sequence's step may not run now, whatever its approval says. A paused sequence or a paused contact sends nothing on either channel; an approval given meanwhile waits for **Resume sequence** (or the contact's own resume). - `hold_reason` 'window' | 'approved_window' | 'daily_cap' | 'no_mailbox' | 'pacing' | 'agent_unavailable' | 'no_message' | 'agent_writing' | 'agent_queued' | 'mailbox_waiting' | 'no_linkedin_account' | 'confirming_send' | 'email_check', required: Why the send path pushed a live contact's ``due_at`` out instead of sending. Stored beside the date it explains so the Contacts tab can say "Approved, window opens in 3 hours" rather than a bare date. Only ever meaningful on an ACTIVE row whose date is still ahead; any other write clears it. - `linkedin_queue` 'running' | 'queued' | 'checking_replies' | 'outside_window' | 'daily_limit' | 'weekly_limit' | 'kind_disabled' | 'browser_offline' | 'verify_account' | 'disconnected', required: Where one step stands in its account's line, for the people waiting on it. ``RUNNING`` is in a browser now. ``QUEUED`` is in line, with how many are ahead of it and when it is expected to start. The rest say why the line is not moving for it: a daily or weekly limit reached for its kind, a limit set to zero (``KIND_DISABLED``, which no reset lifts), no browser checked in for longer than ``offline_warning_seconds``, LinkedIn asking the member to verify the account (a checkpoint), or the account disconnected. Not "paused", which is already what a sequence is when a person stops it. The last two were one "account blocked" state. They are two because the fix is different and the words have to say which: a checkpoint is cleared in the connected Chrome, a disconnect by connecting again. ``OUTSIDE_WINDOW`` is a step whose sequence's sending hours are shut now in its sender's timezone (2026-10-01); it outranks every state but the account's own, since nothing else moves it before the hours open. ``CHECKING_REPLIES`` is a LinkedIn message in line that waits for its sender's inbox to be read first (2026-10-05): no time is named, since it goes once a check reads the whole inbox. - `may_have_sent` boolean, required: A failed LinkedIn message or InMail that may have reached the person anyway (the browser timed out, lost its tab or went silent mid-step): a retry could send it twice, so confirm first. - `pause_reason` string, nullable: For a task its paused sequence holds, why the sequence paused, as the sequence's own `pause_reason` (`manual`, `credits`, `spending_limit`, `bounces`, `mailboxes`, `linkedin`). Null otherwise. - `resets_at` string, date-time, nullable, required: The reset that frees a LinkedIn step a daily or weekly limit holds, midnight in the sender's timezone; null otherwise. - `retryable` boolean, required: The contact is stopped as failed at this moment, so a retry of their journey (the `retry` journey action on their enrolment) runs the step again. - `starts_at` string, date-time, nullable, required: When it is expected to start: a LinkedIn step's forecast, or when a held email's wait ends. An estimate; null when no time can honestly be named. - `state` 'queued' | 'running' | 'sent' | 'skipped' | 'failed' | 'stopped' | 'rejected' | 'sending' | 'held' | 'paused' | 'writing', required: Where a task's work stands once the queue has let it go, for the Tasks page's Detail column. Finer than ``TaskStatus``, and read from the channel rather than the row: a LinkedIn step's own phase and outcome first (the task's status can lag it), the contact's enrolment for an email. ``QUEUED`` in its sender's line, with a forecast, or approved and about to join it; ``RUNNING`` in a browser now; ``SENDING`` an approved email the engine is sending; ``HELD`` an approved email waiting for the sending window, pacing or a daily cap, or an approved LinkedIn step waiting for something its contact names (a connected account); ``PAUSED`` an approved step on either channel that waits for its paused sequence or paused contact to be resumed, in no line until then. ``WRITING`` a task Write again withdrew while the agent writes its contact's words for that step again, or the engine is about to ask with them: the same task comes back waiting on a person. The rest are how it ended: ``SENT``, ``SKIPPED`` (not applicable, or passed over in the extension), ``FAILED``, ``REJECTED`` and ``STOPPED`` (the contact was stopped under it, or it was replaced and the rewrite ended without asking again). - `steps_ahead` integer, nullable, required: How many of the sender's LinkedIn steps run before this one; null otherwise. - `quality_score` integer, nullable, required: A separate AI review's score for the agent's message, from 0 to 100: how likely a busy person in the recipient's role is to read it to the end and reply. Null when no agent wrote the message, or when it was not reviewed. - `reasoning` string, nullable, required: The agent's own note on its message: what it built the message on and what it was unsure about. Null when no agent wrote the message. - `record_id` string, uuid, nullable, required - `rejected_at` string, date-time, nullable, required - `rejected_by_display_name` string, nullable, required - `reply_subject` string, nullable: For an email that replies in the contact's existing thread, the subject it will go out with, such as 'Re: Quick question'. Null for a first email, which carries its own `subject`, and for anything that is not an email. - `resolved_at` string, date-time, nullable, required - `sender_browser_online` boolean, nullable: For a LinkedIn task still waiting on a person: whether a browser is checked in for its sender right now, so approving it would run it soon. False means an approved step waits until a browser is open. Null for every other task. - `sender_profile_id` string, uuid, nullable, required - `sender_profile_name` string, nullable, required: Null when nobody in particular sends it, or the sender was deleted. - `sequence_id` string, uuid, nullable, required - `sequence_name` string, nullable, required: Null for housekeeping work, or for a sequence since deleted. - `sequence_paused` boolean: Its sequence is paused right now: approving the task records the approval, and the step waits for Resume sequence before it runs, on either channel. - `status` 'pending' | 'scheduled' | 'done' | 'rejected' | 'cancelled', required: Where one task stands. PENDING is waiting on a person. SCHEDULED is approved, or never needed approval, and is waiting on the channel to execute it: the browser to run the LinkedIn step, the engine to send the email. The task is where a LinkedIn step's approval lives: while it is PENDING no step exists, and the step is queued only once it is SCHEDULED. A LinkedIn task nobody is asked about (a sender on automatic, a housekeeping read, a Try click) is BORN scheduled, pointing at the step it queued. Who approved it is a stamp on the row, not a status of its own. DONE, REJECTED and CANCELLED are terminal. DONE is the channel executed it; REJECTED is a person refused it; CANCELLED is the channel gave up on it (failed, skipped, expired), or the contact was stopped underneath it. - `step_id` string, uuid, nullable, required - `step_name` string, nullable, required: The step as the builder names it; null when the step no longer exists. - `step_position` integer, nullable, required: The step's customer-visible ordinal, zero-based; null with the name. - `subject` string, nullable, required - `updated_at` string, date-time, required ## Other responses - `401`: Unauthorized - `403`: Forbidden - `404`: Task not found. - `409`: The task is no longer in a state this decision applies to. - `422`: The task carries no message to edit. - `500`: Internal server error. - `502`: Bad gateway error. - `503`: Service unavailable. --- [API](https://skmtc.dev/getoneprofile/apis/api-reference-oneprofile.md) · [All operations](https://skmtc.dev/getoneprofile/apis/api-reference-oneprofile/llms.txt) · [OpenAPI document](https://skmtc.dev/getoneprofile/apis/api-reference-oneprofile/revisions/4a6bd71e3f02?raw)