> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reachboost.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Publish a draft campaign

> Starts a draft campaign, so its senders send its steps on LinkedIn for the first time.
One action for classic and flow campaigns. The campaign needs a sender and a lead
list or API leads. A classic campaign also needs what the app asks for before its
Start campaign button appears: at least one message step, daily limits, active hours,
at least one active day, and senders that are connected to LinkedIn. Each refusal
names the campaign parameter that fixes it in `field` when applicable. Classic
publishing enrolls eligible leads from the selected lists and refuses with
`no_valid_profiles` when none are eligible. Campaigns receiving API leads may start
empty and have automatic finishing disabled. A flow campaign also needs at
least one step and a flow that passes the flow rules. Only a draft can be published: a running campaign answers
`already_published`, and a paused or finished one answers `not_draft` (a paused
campaign is resumed instead).




## OpenAPI

````yaml /api-reference/openapi.yaml post /workspaces/{workspace_uuid}/campaigns/{campaign_uuid}/publish
openapi: 3.0.3
info:
  title: ReachBoost API
  version: '1'
  description: >
    ## Welcome

    The ReachBoost API enables you to take your LinkedIn outreach to the next
    level by integrating ReachBoost directly into your tech stack, workflows, or
    AI agents. With our API, you can automate actions, enrich personalization,
    and build solutions tailored to your outreach strategies.


    ## Authentication


    All requests must include your API key in the `X-Api-Key` header.


    ```

    X-Api-Key: <your_api_key_here>

    ```


    You can find your API key in your ReachBoost account settings.


    ## Base URL


    ```

    https://app.reachboost.io/api/v1

    ```


    Workspace-scoped endpoints use:


    ```

    https://app.reachboost.io/api/v1/workspaces/{workspace_uuid}

    ```


    Your `workspace_uuid` is your unique identifier for the workspace. You can
    find it on the integrations page under the API tab.


    ## Rate Limits


    Requests are limited to **100 requests per minute per API key**. The
    allowance is shared across

    all endpoints: a single API key has one budget, not one budget per resource.
    The window is a

    fixed one-minute window aligned to the clock minute.


    Every response to a request with a recognised API key carries these headers:


    | Header | Meaning |

    |---|---|

    | `X-RateLimit-Limit` | Requests allowed in the current window |

    | `X-RateLimit-Remaining` | Requests left in the current window |

    | `X-RateLimit-Reset` | Unix timestamp when the current window resets |

    | `X-RateLimit-Resource` | Which limit the request counted against |


    When the limit is exceeded the API returns `429 Too Many Requests` with a
    `Retry-After` header

    (seconds until the window resets) and a body of the form:


    ```json

    {
      "error": "Rate limit exceeded. Please try again later.",
      "code": "rate_limit_exceeded",
      "retry_after": 17
    }

    ```


    Recommended client behaviour:


    1. If `Retry-After` is present, wait that many seconds before retrying.

    2. Otherwise, if `X-RateLimit-Remaining` is `0`, wait until
    `X-RateLimit-Reset`.

    3. Otherwise back off exponentially with jitter and cap your retries.


    Note that write requests are not idempotent, so retrying a `POST` or `PATCH`
    after a timeout may

    repeat the operation. Please contact support if you need a higher limit.


    ## Pagination


    List endpoints return paginated results. Control pagination with the `page`
    and `per_page` query parameters.


    | Parameter | Default | Maximum |

    |---|---|---|

    | `page` | `1` | — |

    | `per_page` | `50` | `100` |


    All paginated responses share the same envelope:


    ```json

    {
      "current_page": 1,
      "per_page": 50,
      "total_count": 120,
      "total_pages": 3,
      "next_page": 2,
      "prev_page": null,
      "data": [ ... ]
    }

    ```


    ## Errors


    The API uses standard HTTP status codes.


    | Code | Meaning |

    |---|---|

    | `400` | Bad Request — invalid parameters |

    | `401` | Unauthorized — missing or invalid API key |

    | `404` | Not Found |

    | `413` | Payload Too Large — request body exceeds 1 MB |

    | `422` | Unprocessable Entity — validation error |

    | `429` | Too Many Requests — rate limit exceeded |

    | `500` | Internal Server Error |


    Error responses always include an `error` field:


    ```json

    { "error": "Human-readable error message" }

    ```


    ## Building a flow campaign


    A flow campaign is a tree of steps. Each lead starts at "start", runs each
    step in

    turn, and follows the outcome that step produced to the next one. Every path
    ends

    at an end step. Create the campaign with `POST /campaigns` (CLI: `campaigns
    create`)

    and `flow_enabled: true`, then set its steps with `PUT
    /campaigns/{campaign_uuid}/flow`

    (CLI: `campaigns replace-flow`). Nothing is sent until the campaign is
    published with

    `POST /campaigns/{campaign_uuid}/publish` (CLI: `campaigns publish`).


    ### Step types and their outcomes


    | Step | Settings | Outcomes |

    |---|---|---|

    | connection_request | message_content, fallback_message,
    send_empty_connection_request, wait_before | accepted, not_accepted |

    | follow_up | message_content, fallback_message, wait_before | replied,
    not_replied |

    | voice_note | voice_note_id, wait_before | replied, not_replied |

    | email | subject, message_content, fallback_subject, fallback_message,
    wait_before | replied, not_replied |

    | profile_visit | wait_before | next |

    | profile_follow | wait_before | next |

    | like_last_post | wait_before | next |

    | withdraw | wait_before | next |

    | push_to_integration | integration_kind, integration_id, reference,
    wait_before | next |

    | enrichment | options, wait_before | next |

    | condition | rows, match, wait_before | met, not_met |

    | end | wait_before | none |


    A step with the outcome next has one exit. end has none: it finishes the
    lead.


    ### Which step may follow which outcome


    | After | May be followed by |

    |---|---|

    | start | profile_visit, profile_follow, like_last_post, follow_up,
    voice_note, connection_request, email, condition, enrichment,
    push_to_integration |

    | profile_visit | profile_follow, like_last_post, follow_up, voice_note,
    connection_request, email, withdraw, condition, enrichment,
    push_to_integration, end |

    | profile_follow | profile_visit, like_last_post, follow_up, voice_note,
    connection_request, email, withdraw, condition, enrichment,
    push_to_integration, end |

    | like_last_post | profile_visit, profile_follow, follow_up, voice_note,
    connection_request, email, withdraw, condition, enrichment,
    push_to_integration, end |

    | connection_request / accepted | profile_visit, like_last_post, follow_up,
    voice_note, email, condition, enrichment, push_to_integration, end |

    | connection_request / not_accepted | profile_visit, like_last_post, email,
    withdraw, condition, enrichment, push_to_integration, end |

    | follow_up / replied | condition, enrichment, push_to_integration, end |

    | voice_note / replied | condition, enrichment, push_to_integration, end |

    | follow_up / not_replied | profile_visit, like_last_post, follow_up,
    voice_note, email, condition, enrichment, push_to_integration, end |

    | voice_note / not_replied | profile_visit, like_last_post, follow_up,
    voice_note, email, condition, enrichment, push_to_integration, end |

    | email / replied | end |

    | email / not_replied | profile_visit, profile_follow, like_last_post,
    follow_up, voice_note, connection_request, email, withdraw, condition,
    enrichment, push_to_integration, end |

    | withdraw | profile_visit, profile_follow, like_last_post, email,
    condition, enrichment, push_to_integration, end |

    | push_to_integration | profile_visit, profile_follow, like_last_post,
    follow_up, voice_note, connection_request, email, withdraw, condition,
    enrichment, push_to_integration, end |

    | condition / met | profile_visit, profile_follow, like_last_post,
    connection_request, follow_up, voice_note, email, withdraw, condition,
    enrichment, push_to_integration, end |

    | condition / not_met | profile_visit, profile_follow, like_last_post,
    connection_request, follow_up, voice_note, email, withdraw, condition,
    enrichment, push_to_integration, end |

    | enrichment | profile_visit, profile_follow, like_last_post,
    connection_request, follow_up, voice_note, email, withdraw, enrichment,
    push_to_integration, condition, end |


    ### Waits


    settings.wait_before is { "amount": 3, "unit": "days" }, with unit days or
    weeks.

    It is how long the step waits before it runs.


    - On the step that follows not_accepted it is required, and it is how long
    to wait for the connection request to be accepted. 3 weeks is a common
    choice.

    - On the step that follows not_replied it is how long to wait for a reply.
    It is required after email; leave it out after follow_up or voice_note to
    continue immediately.


    ### Messages


    connection_request, follow_up and email take settings.message_content. Email
    also takes

    settings.subject. A connection request can be sent without a note by setting

    send_empty_connection_request to true and leaving message_content out.


    Merge tags are written with double square brackets: [[first_name]],
    [[last_name]], [[job_role]], [[company_name]],
    [[linkedin_account.first_name]], [[linkedin_account.last_name]].

    Any other spelling, such as {first_name} or {{first_name}}, is sent to the
    lead as

    literal text.


    A message that uses a merge tag needs settings.fallback_message: the text
    sent when

    the lead is missing that value. An email subject that uses a merge tag needs

    settings.fallback_subject the same way. A fallback cannot use merge tags
    itself.


    ### Voice notes


    A voice_note step sends a recorded audio message on LinkedIn, and counts as
    a follow-up for

    limits and statistics. Upload the audio first with `POST
    /campaigns/{campaign_uuid}/voice_notes` (CLI: `campaigns upload-voice-note`)

    (MP3, M4A, WAV or WebM, at most 12 MB and 60 seconds), then set the returned
    id as

    settings.voice_note_id. Leave voice_note_id out to keep the note the step
    already has.

    It is only sent to 1st-degree connections.


    ### Conditions


    A condition step checks the lead and continues on met or not_met.
    settings.rows is a

    list of checks, all of which must pass. settings.match can only be "all".


    - Lead fields: first_name, last_name, linkedin_profile_url, email,
    phone_number, city, country_code, job_role, company_name, company_domain.
    Operators: equals, not_equals, contains, not_contains, empty, not_empty. All
    but
      empty and not_empty need a "value".
      Example: { "field": "city", "op": "equals", "value": "Amsterdam" }
    - { "field": "connection_degree", "op": "is_first_degree" }: the lead is
    already a connection.

    - { "field": "connected_to_sender", "op": "any_of", "value": [sender uuids]
    }: the lead is
      connected to one of these senders.

    ### Other steps


    - enrichment: settings.options lists what to look up, from linkedin_profile,
    email, phone.

    - push_to_integration: settings.integration_kind is one of hubspot, webhook,
    and
      settings.integration_id comes from `GET /integrations` (CLI: `integrations list`).

    ### Rules


    A flow that breaks any of these is refused, and nothing is saved.


    - The flow must start with a step connected from Start.

    - Start can connect to only one first step.

    - Every branch must have a next step.

    - Each outcome can have only one next step.

    - Steps cannot merge; each step has at most one incoming connection.

    - Every path must end with an End step.

    - Only one connection request is allowed.

    - A connection request cannot follow a follow-up.

    - A follow-up cannot sit on the not-accepted branch after a connection
    request.

    - Only one withdraw is allowed.

    - Withdraw requires a connection request in the flow.

    - Withdraw must sit on the not-accepted branch.

    - Only one Profile follow is allowed.

    - A Profile follow cannot come after a connection request or a follow-up:
    sending the request already follows the lead, and a connection is followed
    too.

    - Only one Like last post is allowed.

    - After a reply, only Condition, Enrich, Push to Integration and End are
    allowed.

    - Set a wait on this step. This branch cannot continue immediately.

    - Wait must be a positive amount in days or weeks.

    - Wait is not allowed on the first step after Start.

    - Wait on End is only allowed on a branch that requires a wait.

    - Message cannot be blank.

    - Subject cannot be blank.

    - Add a fallback message when the primary uses merge tags.

    - Add a fallback subject when the subject uses merge tags.

    - Add a fallback message when the message uses merge tags.

    - Fallback content cannot use variables.

    - Conditions can only be combined with AND.

    - Add at least one condition.

    - Enter a value for this condition.

    - Select at least one sender.

    - Choose at least one enrichment option.

    - Select an integration to push the lead to.

    - Record or upload a voice note for this step.


    Publishing, and changing a campaign that has already run:


    - Select at least one audience before publishing.

    - Add at least one step before publishing.

    - This campaign's flow structure is locked. You can still edit the limits,
    step content and wait times.

    - This step cannot be removed because it already has campaign activity.


    ### Example


    Visit the profile, send a connection request, and follow up twice. Withdraw
    the

    request if it is not accepted within 3 weeks.


    ```json

    {
      "nodes": [
        {
          "ref": "visit",
          "type": "profile_visit"
        },
        {
          "ref": "connect",
          "type": "connection_request",
          "settings": {
            "message_content": "Hi [[first_name]], I'd like to connect.",
            "fallback_message": "Hi, I'd like to connect."
          }
        },
        {
          "ref": "follow_up_1",
          "type": "follow_up",
          "settings": {
            "wait_before": {
              "amount": 2,
              "unit": "days"
            },
            "message_content": "Thanks for connecting, [[first_name]]!",
            "fallback_message": "Thanks for connecting!"
          }
        },
        {
          "ref": "follow_up_2",
          "type": "follow_up",
          "settings": {
            "wait_before": {
              "amount": 3,
              "unit": "days"
            },
            "message_content": "Just following up on my last message."
          }
        },
        {
          "ref": "withdraw",
          "type": "withdraw",
          "settings": {
            "wait_before": {
              "amount": 3,
              "unit": "weeks"
            }
          }
        },
        {
          "ref": "end_replied",
          "type": "end"
        },
        {
          "ref": "end_replied_late",
          "type": "end"
        },
        {
          "ref": "end_no_reply",
          "type": "end"
        },
        {
          "ref": "end_withdrawn",
          "type": "end"
        }
      ],
      "edges": [
        {
          "from": "start",
          "to": "visit",
          "outcome": "next"
        },
        {
          "from": "visit",
          "to": "connect",
          "outcome": "next"
        },
        {
          "from": "connect",
          "to": "follow_up_1",
          "outcome": "accepted"
        },
        {
          "from": "connect",
          "to": "withdraw",
          "outcome": "not_accepted"
        },
        {
          "from": "follow_up_1",
          "to": "end_replied",
          "outcome": "replied"
        },
        {
          "from": "follow_up_1",
          "to": "follow_up_2",
          "outcome": "not_replied"
        },
        {
          "from": "follow_up_2",
          "to": "end_replied_late",
          "outcome": "replied"
        },
        {
          "from": "follow_up_2",
          "to": "end_no_reply",
          "outcome": "not_replied"
        },
        {
          "from": "withdraw",
          "to": "end_withdrawn",
          "outcome": "next"
        }
      ]
    }

    ```


    ## Webhooks


    Webhooks let ReachBoost push real-time events to your own endpoint.
    Configure webhooks from the integrations page under the API tab, or through
    the API with the [Webhooks endpoints](#reachboost-api/tag/webhooks):

    1. Set a destination URL

    2. Select which events you want to receive


    ### Delivery


    Each subscribed event is delivered as an HTTP `POST` with a JSON body and a
    `Content-Type: application/json` header. A delivery is considered successful
    on a `2xx` response. Failed deliveries are retried up to **3 times** with
    exponential backoff (2, 4, then 8 minutes). Requests time out after 30
    seconds.


    Every payload includes an `event_type` field identifying the event, and a
    `timestamp_utc` (ISO 8601, UTC) marking when it occurred. When lead
    enrichment is enabled on the webhook, enrichment fields such as `email` and
    `phone_number` are included when available.


    ### Objects and events


    ReachBoost pushes four objects. Each object is delivered by one or more
    events, distinguished by the `event_type` field.


    #### Campaign Activity


    Fired as a lead moves through a campaign's connection and messaging steps.


    | Event | Description |

    |---|---|

    | `connection_request_sent` | A connection request was sent to the lead. |

    | `connection_request_accepted` | The lead accepted the connection request.
    |

    | `connection_request_withdrawn` | A pending connection request was
    withdrawn. |

    | `follow_up_message_sent` | A follow-up message was sent to the lead. |

    | `message_replied` | The lead replied to a message. |


    ```json

    {
      "event_type": "connection_request_accepted",
      "profile_uuid": "9001c8bc-146c-484f-a377-06c4a90ebe72",
      "first_name": "Jane",
      "last_name": "Doe",
      "linkedin_url": "https://www.linkedin.com/in/jane-doe",
      "sender_name": "John Doe",
      "sender_uuid": "6b8accff-7460-431e-9e2f-aeeac7c6916f",
      "campaign_name": "Example Campaign",
      "campaign_uuid": "9a4330fd-4d82-490f-a6a5-eaaabf5ea4dd",
      "message_content": "Thanks for connecting!",
      "message_sequence": 1,
      "reply_content": "Happy to connect.",
      "email": "jane@example.com",
      "phone_number": "+1 555 0100",
      "timestamp_utc": "2026-07-24T10:15:00Z"
    }

    ```


    `reply_content` is included only for `message_replied`. `message_sequence`
    is `null` when not applicable.


    #### Message


    Fired when a message is sent or received in the unified inbox.


    | Event | Description |

    |---|---|

    | `message_success` | A message was successfully sent or received. |


    ```json

    {
      "event_type": "message_success",
      "message_uuid": "4f79dc94-5568-4661-bca7-f8769798d4a8",
      "conversation_uuid": "cf3ca4a0-ae1e-45d2-8bca-8a9ac6b3669f",
      "profile_uuid": "9001c8bc-146c-484f-a377-06c4a90ebe72",
      "first_name": "Jane",
      "last_name": "Doe",
      "linkedin_url": "https://www.linkedin.com/in/jane-doe",
      "sender_name": "John Doe",
      "sender_uuid": "6b8accff-7460-431e-9e2f-aeeac7c6916f",
      "status": "success",
      "direction": "out",
      "content": "Great speaking with you.",
      "delivered_at_utc": "2026-07-24T10:20:00Z",
      "email": "jane@example.com"
    }

    ```


    #### Lead Status


    Fired when a lead's status changes in your pipeline.


    | Event | Description |

    |---|---|

    | `lead_status_engaged` | Lead moved to Engaged. |

    | `lead_status_interested` | Lead moved to Interested. |

    | `lead_status_hot_lead` | Lead moved to Hot lead. |

    | `lead_status_meeting_booked` | Lead moved to Meeting booked. |

    | `lead_status_won` | Lead moved to Won. |

    | `lead_status_not_interested` | Lead moved to Not interested. |

    | `lead_status_lost` | Lead moved to Lost. |


    ```json

    {
      "event_type": "lead_status_interested",
      "profile_uuid": "9001c8bc-146c-484f-a377-06c4a90ebe72",
      "first_name": "Jane",
      "last_name": "Doe",
      "linkedin_url": "https://www.linkedin.com/in/jane-doe",
      "lead_status": "interested",
      "previous_lead_status": "engaged",
      "email": "jane@example.com",
      "timestamp_utc": "2026-07-24T10:25:00Z"
    }

    ```


    #### Campaign Profile


    Fired when a lead reaches a terminal state within a campaign.


    | Event | Description |

    |---|---|

    | `lead_finished` | The lead completed the campaign. |

    | `lead_failed` | The lead could not be processed and stopped with a
    failure. |


    ```json

    {
      "event_type": "lead_failed",
      "profile_uuid": "9001c8bc-146c-484f-a377-06c4a90ebe72",
      "first_name": "Jane",
      "last_name": "Doe",
      "linkedin_url": "https://www.linkedin.com/in/jane-doe",
      "sender_name": "John Doe",
      "sender_uuid": "6b8accff-7460-431e-9e2f-aeeac7c6916f",
      "campaign_name": "Example Campaign",
      "campaign_uuid": "9a4330fd-4d82-490f-a6a5-eaaabf5ea4dd",
      "status": "failed",
      "email": "jane@example.com",
      "timestamp_utc": "2026-07-24T10:30:00Z"
    }

    ```
  contact:
    name: ReachBoost Support
    url: https://reachboost.io
servers:
  - url: https://app.reachboost.io/api/v1
    description: Production
security:
  - ApiKeyAuth: []
tags:
  - name: Statistics
    description: >-
      Campaign performance metrics for a date range, with optional sender and
      campaign filters.
  - name: Leads
    description: Manage leads, including lead tags and custom fields.
  - name: Lead Lists
    description: Manage lead lists in your workspace via API.
  - name: Campaigns
    description: Manage campaigns in your workspace via API.
  - name: Campaign Messages
    description: Manage messages from campaigns via API.
  - name: Senders
    description: Manage LinkedIn senders connected to your workspace via API.
  - name: Unified Inbox
    description: Read conversations and send messages through the unified inbox via API.
  - name: Tags
    description: Manage tags used to organize leads in your workspace via API.
  - name: Workspaces
    description: Manage all workspaces in your agency.
  - name: Users
    description: >-
      Manage the members of a workspace and the invitations that bring new
      members in. Both resources live here.
  - name: Webhooks
    description: >-
      Manage the outbound webhooks of a workspace, the URLs that receive a POST
      for each chosen event. Not available on agency workspaces.
  - name: Integrations
    description: >-
      The integrations a flow campaign's Push to Integration step can send leads
      to. Not available on agency workspaces.
paths:
  /workspaces/{workspace_uuid}/campaigns/{campaign_uuid}/publish:
    post:
      tags:
        - Campaigns
      summary: Publish a draft campaign
      description: >
        Starts a draft campaign, so its senders send its steps on LinkedIn for
        the first time.

        One action for classic and flow campaigns. The campaign needs a sender
        and a lead

        list or API leads. A classic campaign also needs what the app asks for
        before its

        Start campaign button appears: at least one message step, daily limits,
        active hours,

        at least one active day, and senders that are connected to LinkedIn.
        Each refusal

        names the campaign parameter that fixes it in `field` when applicable.
        Classic

        publishing enrolls eligible leads from the selected lists and refuses
        with

        `no_valid_profiles` when none are eligible. Campaigns receiving API
        leads may start

        empty and have automatic finishing disabled. A flow campaign also needs
        at

        least one step and a flow that passes the flow rules. Only a draft can
        be published: a running campaign answers

        `already_published`, and a paused or finished one answers `not_draft` (a
        paused

        campaign is resumed instead).
      operationId: publishCampaign
      parameters:
        - $ref: '#/components/parameters/WorkspaceUuid'
        - $ref: '#/components/parameters/CampaignUuid'
      responses:
        '200':
          description: Campaign published
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Campaign'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          $ref: '#/components/responses/NotFound'
        '422':
          $ref: '#/components/responses/FlowUnprocessableEntity'
        '429':
          $ref: '#/components/responses/TooManyRequests'
components:
  parameters:
    WorkspaceUuid:
      name: workspace_uuid
      in: path
      required: true
      description: Your unique workspace identifier.
      schema:
        type: string
        format: uuid
        example: YOUR_WORKSPACE_UUID
    CampaignUuid:
      name: campaign_uuid
      in: path
      required: true
      description: The unique identifier for the campaign.
      schema:
        type: string
        format: uuid
        example: YOUR_CAMPAIGN_UUID
  schemas:
    Campaign:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        status:
          type: string
          enum:
            - draft
            - active
            - inactive
            - finished
        name:
          type: string
        description:
          type: string
          nullable: true
        campaign_type:
          type: string
          enum:
            - new_connections
            - existing_connections
        flow_enabled:
          type: boolean
          description: >-
            Whether this is a flow campaign, whose steps are read and replaced
            through the campaign flow endpoint. Fixed when the campaign is
            created.
        senders:
          type: array
          items:
            type: string
            format: uuid
          description: List of sender UUIDs assigned to this campaign.
        connection_request_limit:
          $ref: '#/components/schemas/ConnectionRequestLimit'
        follow_up_limit:
          $ref: '#/components/schemas/ConnectionRequestLimit'
        active_hours_utc:
          allOf:
            - $ref: '#/components/schemas/ActiveHours'
          nullable: true
        active_days:
          $ref: '#/components/schemas/ActiveDays'
        lead_list_uuids:
          type: array
          items:
            type: string
            format: uuid
          description: >-
            UUIDs of lead lists to use as the source of leads. Send an empty
            array to insert leads via the API instead of using lead lists. Send
            an empty array to insert leads via the API instead of using lead
            lists.
        exclude:
          $ref: '#/components/schemas/ExcludeOptions'
        auto_finish:
          type: boolean
        finished_at:
          type: string
          format: date-time
          nullable: true
        updated_at:
          type: string
          format: date-time
        created_at:
          type: string
          format: date-time
      example:
        uuid: 9a4330fd-4d82-490f-a6a5-eaaabf5ea4dd
        status: draft
        name: Example Campaign
        description: Example for API documentation
        campaign_type: new_connections
        flow_enabled: false
        senders:
          - 6b8accff-7460-431e-9e2f-aeeac7c6916f
        connection_request_limit:
          min: 10
          max: 15
        follow_up_limit:
          min: 10
          max: 15
        active_hours_utc:
          from: '09:00'
          to: '17:00'
        active_days:
          monday: true
          tuesday: true
          wednesday: true
          thursday: true
          friday: true
          saturday: false
          sunday: false
        lead_list_uuids:
          - 0d13ca65-af91-4de0-b741-8e865917eaaa
        exclude:
          already_active_campaign: true
          already_contacted_workspace: false
          already_contacted_selected_senders: false
        auto_finish: true
        finished_at: '2025-11-01T09:00:00+01:00'
        updated_at: '2025-10-10T09:00:00+01:00'
        created_at: '2025-10-01T09:00:00+01:00'
    ConnectionRequestLimit:
      type: object
      properties:
        min:
          type: integer
          nullable: true
        max:
          type: integer
          nullable: true
    ActiveHours:
      type: object
      description: >-
        Active hours as HH:MM in UTC at today's offset. The campaign follows the
        local time in the workspace timezone, so these values move by one hour
        across a daylight saving change.
      properties:
        from:
          type: string
          example: '09:00'
        to:
          type: string
          example: '17:00'
    ActiveDays:
      type: object
      properties:
        monday:
          type: boolean
        tuesday:
          type: boolean
        wednesday:
          type: boolean
        thursday:
          type: boolean
        friday:
          type: boolean
        saturday:
          type: boolean
        sunday:
          type: boolean
    ExcludeOptions:
      type: object
      properties:
        already_active_campaign:
          type: boolean
        already_contacted_workspace:
          type: boolean
        already_contacted_selected_senders:
          type: boolean
    Error:
      type: object
      properties:
        error:
          type: string
        code:
          type: string
          description: >-
            Present on refusals a script may need to tell apart, for example
            `flow_campaign_use_flow_endpoint` when a campaign message write
            targets a flow campaign.
    FlowErrorResponse:
      type: object
      required:
        - error
        - errors
      properties:
        error:
          type: string
          description: >-
            The first error's message, the same field every other error response
            has.
        errors:
          type: array
          items:
            $ref: '#/components/schemas/FlowError'
    RateLimitError:
      type: object
      properties:
        error:
          type: string
          example: Rate limit exceeded. Please try again later.
        code:
          type: string
          example: rate_limit_exceeded
        retry_after:
          type: integer
          description: Seconds until the current rate-limit window resets.
          example: 17
    FlowError:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: string
          description: >
            What went wrong, for example `missing_node_id`, `ambiguous_node_id`,

            `unknown_node_id`, `duplicate_ref`, `reserved_ref`,
            `unknown_edge_endpoint`,

            `invalid_outcome`, `unknown_setting`, `invalid_setting`,
            `invalid_body`, `structure_locked`,

            `step_in_use`, a placement rule such as `invalid_adjacency`, or for
            publish

            `already_published`, `not_draft`, `empty_flow`, `sender_required`,

            `sender_not_connected`, `steps_required`, `limits_required`,

            `working_hours_required`, `active_days_required`,
            `audience_required`.
        message:
          type: string
        node_id:
          type: string
          description: >-
            The existing step the error is about, or `"start"` for the first
            edge.
        ref:
          type: string
          description: The new step the error is about, by the `ref` it was sent with.
        field:
          type: string
          description: >-
            Where the bad value is. Relative to the step when `node_id` or `ref`
            is set (`settings.message_content`), indexed in the body when
            neither is available (`nodes[2].settings.message_content`,
            `nodes[2]` or `edges[0]`), or a campaign parameter such as `senders`
            or `lead_list_uuids`.
        outcome:
          type: string
          description: The outcome of the step the error is about.
  responses:
    Unauthorized:
      description: Unauthorized
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: Invalid API key
    NotFound:
      description: Not Found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: Resource not found
    FlowUnprocessableEntity:
      description: >-
        Unprocessable Entity. `error` is the first message; `errors` lists every
        problem found.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/FlowErrorResponse'
          example:
            error: Message cannot be blank.
            errors:
              - code: blank_message
                message: Message cannot be blank.
                ref: thanks
                field: settings.message_content
    TooManyRequests:
      description: >
        Too Many Requests — the API key exceeded its rate limit. Wait for the
        period given by

        `Retry-After` before retrying.
      headers:
        X-RateLimit-Limit:
          $ref: '#/components/headers/XRateLimitLimit'
        X-RateLimit-Remaining:
          $ref: '#/components/headers/XRateLimitRemaining'
        X-RateLimit-Reset:
          $ref: '#/components/headers/XRateLimitReset'
        X-RateLimit-Resource:
          $ref: '#/components/headers/XRateLimitResource'
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/RateLimitError'
          example:
            error: Rate limit exceeded. Please try again later.
            code: rate_limit_exceeded
            retry_after: 17
  headers:
    XRateLimitLimit:
      description: Requests allowed in the current rate-limit window.
      schema:
        type: integer
        example: 100
    XRateLimitRemaining:
      description: Requests left in the current rate-limit window.
      schema:
        type: integer
        example: 42
    XRateLimitReset:
      description: Unix timestamp at which the current rate-limit window resets.
      schema:
        type: integer
        example: 1787660460
    XRateLimitResource:
      description: Which rate limit the request counted against.
      schema:
        type: string
        example: default
    RetryAfter:
      description: Seconds to wait before retrying.
      schema:
        type: integer
        example: 17
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-Api-Key
      description: Your secret ReachBoost API key.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.