---
title: "Approve a task"
method: POST
path: "/outreach-tasks/{task_id}/approve/"
tags: ["outreach"]
---

# Approve a task

`POST /outreach-tasks/{task_id}/approve/`

## 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}/approve/`
- Auth: one of:
  - API key in header `X-API-Key`
  - HTTP bearer

Let a pending task run, and record who said so. An approved LinkedIn step joins its sender's line, and whichever browser holds the lease performs it in turn: a reply at once, a sequence's step through the send engine, which holds it while its sequence or contact is paused. An approved email is sent at once, or when its sequence's sending window opens. The answer is the task's row plus `schedule`, the same forecast the bulk approve gives: when the step is expected to run and what would stop it. 409 when the task is no longer pending, or when its step cannot be taken now (the sender's LinkedIn is not connected, the connection request it would withdraw is no longer pending, the send engine could not take a sequence's step just now); the task then still waits. When the person opened the task first (`opened`), words the agent wrote that nobody changed are recorded as approved as written: their Looks good, kept as a record that never trains the agent.

## Path parameters

- `task_id` string, uuid, required

## Request body

- OutreachTaskApproveSchema: Whether the person read the task before approving it.
  - `opened` boolean: The person opened the task and read its message before approving. Words the agent wrote that they approved without changing are then recorded as approved as written: a record of their Looks good, which never trains the agent.

## Response `200`

Successful Response

- OutreachTaskApprovalReadSchema: One approved task's row, and when the work it let go is expected to run.
  - `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
  - `schedule` OutreachApprovalScheduleReadSchema: When the work an approval just let go is expected to run, per channel.
    - `email_count` integer, required: How many approved emails the engine now sends.
    - `email_held` integer: How many of the approved emails wait for their paused sequence to be resumed. They go out after Resume sequence, not before.
    - `email_starts_at` string, date-time, nullable, required: When the approved emails start, if every one of their running sequences' sending windows is closed now: the earliest opening. Null when they go now, or when every one of them waits for a paused sequence.
    - `linkedin` LinkedInApprovalScheduleReadSchema[], required: One entry per sender whose LinkedIn steps were approved.
      - `account_id` string, uuid, required
      - `after_reset` integer, required: How many wait for that reset or later.
      - `before_reset` integer, required: How many are expected to start before the next daily reset (midnight in the sender's timezone).
      - `blocked` 'browser_offline' | 'account_blocked' | 'weekly_limit' | 'kind_disabled' | 'outside_window', required: The one thing that stops a batch of approved steps from running as scheduled.
      - `count` integer, required: How many of the approved steps are this sender's.
      - `first_at` string, date-time, nullable, required: When the first of them starts; null when no time can be named.
      - `held` integer: How many of them wait for their paused sequence or paused contact to be resumed. They are in no line until then, and the counts and times above leave them out.
      - `last_at_estimate` string, date-time, nullable, required: When the last of them is expected to start; null when it cannot be named.
      - `opens_at` string, date-time, nullable: When the sending hours the first of them waits for open; null when none wait for them.
      - `outside_window` integer: How many of them wait for their sequence's sending hours, shut now in the sender's timezone.
      - `resets_at` string, date-time, nullable, required: The daily reset those wait for; null when none do.
      - `sender_name` string, required: The sender as the Senders page names them.
      - `sender_profile_id` string, uuid, 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`: Invalid request made to the API.
- `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)