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

# Restore a sequence from Trash

> Take a sequence out of Trash. A launched one comes back paused, and only Resume starts it again; a draft comes back a draft. Its contacts are taken back where they stood, in the background, unless another sequence took them meanwhile (contacts_held_elsewhere counts them: they stay stopped), they replied, or their row left the audience.

Fails while a live sequence has its name: rename one of the two first.



## OpenAPI

````yaml /openapi.json post /sequences/{sequence_id}/restore/
openapi: 3.1.0
info:
  contact:
    email: support@getoneprofile.ai
    name: Oneprofile Support
  description: >-
    REST API reference for Oneprofile, the GTM data layer for your CRM. Manage
    tables, enrichments, and integrations. Authenticate with an API key to get
    started.
  termsOfService: https://www.getoneprofile.ai/terms
  title: API Reference | Oneprofile
  version: '0.0'
servers:
  - url: https://api.getoneprofile.ai
security: []
tags:
  - description: >-
      The docked AI Assistant: its general chat about the workspace and the
      product, streamed as Server-Sent Events, and the one list of a person's
      threads across every assistant, with pin, rename, delete and the
      search-to-table link.
    name: assistant
  - description: >-
      The messages a person keeps to send the assistant again: the ones the
      workspace saved and the ones that ship with the product, with save,
      rename, edit and delete.
    name: assistant-prompt
  - description: >-
      Granted workspace actions: what the AI Assistant proposed or applied in a
      conversation, the approve and dismiss decisions on each card, the
      workspace's spend threshold and default grants, and the eight verbs.
    name: workspace-actions
  - description: >-
      The Getting started checklist: a workspace's progress through the six
      steps from its first people search to its first launched sequence.
    name: onboarding
  - description: Senders, connected mailboxes, tags, and the Google connect flow.
    name: senders
  - description: The workspace do-not-contact list, enforced before every send.
    name: suppression
  - description: >-
      The workspace's recontact rule: how long before anyone hears from us
      again.
    name: contact_cooldown
  - description: 'Sequence authoring: the graph, the table-backed audience, previews.'
    name: sequences
  - description: >-
      The outbound agent behind a sequence: the voice it writes in, its
      per-message prompts, what it wrote and what people told it.
    name: outbound-agents
  - description: >-
      The LinkedIn channel: connecting an account to a sender, its safety limits
      and history, and the protocol the browser extension speaks.
    name: linkedin
  - description: >-
      The approval queue: everything waiting on a person across every sender and
      channel, and the workspace's manual or automatic modes per channel.
    name: outreach
  - description: 'The unified outreach inbox: threads, replies, labels, events.'
    name: inbox
  - description: 'The AI reply layer: workspace settings, drafts, and approval.'
    name: inbox-ai
  - description: Notification rules, per-user preferences, and the Slack connection.
    name: notifications
  - description: Endpoints for seeing all available integration types.
    name: integration-types
  - description: Endpoints for creating and managing integrations.
    name: integrations
  - description: Endpoints for the generic OAuth install/claim app-listings engine.
    name: app-listings
  - description: Endpoints for creating and managing API keys.
    name: apikey
  - description: >-
      AI apps connected to the workspace: Claude, ChatGPT, Claude Code or any
      other MCP client a person signed in to Oneprofile's MCP server with.
    name: ai_apps
  - description: Endpoints for managing billing and subscription information.
    name: billing
  - description: Endpoints for creating and managing tables.
    name: tables
  - description: Endpoints for table columns, formula previews, and on-demand column runs.
    name: table-columns
  - description: Endpoints for table rows and manual cell edits.
    name: table-rows
  - description: Endpoints for observing and cancelling table recompute runs.
    name: table-runs
  - description: >-
      Endpoints for org-shared per-column display preferences: hidden, pinned,
      width, and colour tint.
    name: table-ui-prefs
  - description: >-
      Endpoints for the org-shared names given to the column tint palette: what
      this organisation calls each colour. Org-level, not per-table.
    name: table-column-color-labels
  - description: >-
      Endpoints for the enrichment action catalog, model list, presets, draft
      generation, and saved agents.
    name: table-enrichments
  - description: >-
      Endpoints for an agent's Preview: example rows run one at a time, and a
      Looks good on each. Needs work lives under agent-learnings.
    name: agent-training
  - description: >-
      An agent's learnings, the one-line rules it follows on every output, and
      the thumbs down that teaches them: give one with what was wrong, list the
      ones on a subject, Undo one, and price the redo it would run.
    name: agent-learnings
  - description: >-
      The durable audit trail of a table's enrichment actions: configured,
      edited, run, cancelled, and settled cost.
    name: table-enrichment-audit-logs
  - description: Endpoints for saving and applying column templates.
    name: table-templates
  - description: Server-sent change feed for a table's grid.
    name: table-events
  - description: 'Endpoints for org-shared saved table views: sort, filters, hidden columns.'
    name: table-views
  - description: >-
      Endpoints for PER-USER table preferences: favourites and recently opened.
      Unlike the rest of the table surface these are personal, so two members of
      one organisation legitimately see different answers.
    name: table-user-prefs
  - description: >-
      Endpoints for building a table from an uploaded CSV: upload and preview
      the inferred columns, commit the reviewed mapping, then poll the row load.
    name: table-imports
  - description: Endpoint for downloading a table's rows as CSV.
    name: table-export
  - description: >-
      Endpoints for the integration a table imports from: attach and preview it,
      promote imported fields into columns, and run the import on demand.
    name: table-sources
  - description: >-
      Endpoints for a table's recurring import cadence: set it, pause it, and
      read the next fire times.
    name: table-schedules
  - description: >-
      Endpoints for pushing a table's rows out to a connected integration: list
      writable destinations, derive their write capabilities, and map export
      columns.
    name: table-writeback
  - description: >-
      Endpoints backing a lookup column's setup: the connections whose records a
      column could read, and the identity fields one record type can be looked
      up by.
    name: table-integration-lookup
  - description: >-
      Endpoints for sourcing leads from the lead database: count and preview
      matches, land them in a table, and keep saved searches. Alongside people
      and company searches, leads can be sourced from buying signals (what a
      company or person just did), with a catalogue endpoint behind the picker
      that builds them.
    name: find-leads
  - description: >-
      Endpoints for discovering a domain's subdomains from public certificate
      logs and landing the results in a table.
    name: find-subdomains
  - description: Endpoints for the credit balance meter and usage reporting.
    name: credits
  - description: >-
      Endpoints for the workspace referral program: the shareable link, the
      friends who joined through it, and claiming a code after signup.
    name: referral
  - description: >-
      Endpoints for the affiliate program's own dashboard: enrolling and
      claiming a code, the summary, stats and activity feed, the commission
      ledger, and identity verification and payouts.
    name: affiliate
  - description: >-
      Endpoints for recording where a new workspace came from: the marketing
      page or campaign its signup link carried, sent once after signup.
    name: attribution
  - description: >-
      Endpoints for the design partner program's customer surface: whether this
      workspace is a design partner, the badges its feedback has earned, and
      sending and reading that feedback.
    name: design-partner
  - description: >-
      Endpoints for the org-level AI business context (company description,
      ideal customer profile, buyer personas, interest signals and social
      proof), plus domain-based generation and the reference documents whose
      summaries ride alongside those fields.
    name: ai-context
  - description: >-
      Endpoints for the signed-in user's Google Drive connection: starting and
      finishing the OAuth grant, checking or dropping it, and minting the
      short-lived token the Google Picker needs.
    name: google-drive
paths:
  /sequences/{sequence_id}/restore/:
    post:
      tags:
        - sequences
      summary: Restore a sequence from Trash
      description: >-
        Take a sequence out of Trash. A launched one comes back paused, and only
        Resume starts it again; a draft comes back a draft. Its contacts are
        taken back where they stood, in the background, unless another sequence
        took them meanwhile (contacts_held_elsewhere counts them: they stay
        stopped), they replied, or their row left the audience.


        Fails while a live sequence has its name: rename one of the two first.
      operationId: restore_sequence
      parameters:
        - in: path
          name: sequence_id
          required: true
          schema:
            format: uuid
            title: Sequence Id
            type: string
        - description: Report the sequence as it would come back, and restore nothing.
          in: query
          name: dry_run
          required: false
          schema:
            default: false
            description: Report the sequence as it would come back, and restore nothing.
            title: Dry Run
            type: boolean
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SequenceRestoreReadSchema'
          description: Successful Response
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedResponse'
          description: Unauthorized
        '403':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ForbiddenResponse'
          description: Forbidden
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NotFoundResponse'
          description: Not found in Trash.
        '422':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnprocessableEntityResponse'
          description: Validation failed.
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ServerErrorResponse'
          description: Internal server error.
        '502':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ServerErrorResponse'
          description: Bad gateway error.
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ServerErrorResponse'
          description: Service unavailable.
      security:
        - APIKeyHeader: []
        - HTTPBearer: []
components:
  schemas:
    SequenceRestoreReadSchema:
      description: A sequence taken out of Trash, and the contacts it could not take back.
      properties:
        contacts_held_elsewhere:
          description: >-
            Contacts another sequence took while this one was in Trash. They
            stay stopped here (Stopped in Trash). One who replied, bounced or
            left the audience stops for that instead, and is not counted. A
            draft holds nobody, so it takes every contact back and this is 0.
            The rest are taken back where they stood, in the background, a
            moment after this answers.
          title: Contacts Held Elsewhere
          type: integer
        sequence:
          $ref: '#/components/schemas/SequenceReadSchema'
      required:
        - sequence
        - contacts_held_elsewhere
      title: SequenceRestoreReadSchema
      type: object
    UnauthorizedResponse:
      properties:
        detail:
          description: The detail of why the request is unauthorized.
          title: Detail
          type: string
      required:
        - detail
      title: UnauthorizedResponse
      type: object
    ForbiddenResponse:
      properties:
        detail:
          description: The detail of why the request is forbidden.
          title: Detail
          type: string
      required:
        - detail
      title: ForbiddenResponse
      type: object
    NotFoundResponse:
      properties:
        detail:
          description: The detail of why the resource was not found.
          title: Detail
          type: string
      required:
        - detail
      title: NotFoundResponse
      type: object
    UnprocessableEntityResponse:
      properties:
        detail:
          description: >-
            The detail of the error. This is the error message to show to the
            user. You should also use the issues field to show more detailed
            error messages per field. Use this field for a single liner error
            message.
          title: Detail
          type: string
        issues:
          description: >-
            The issues that caused the error. There can be multiple issues. Each
            issue is a user-facing error message.
          items:
            $ref: '#/components/schemas/UnprocessableEntityIssue'
          title: Issues
          type: array
      required:
        - detail
        - issues
      title: UnprocessableEntityResponse
      type: object
    ServerErrorResponse:
      properties:
        detail:
          description: The detail of why the server returned an error.
          title: Detail
          type: string
      required:
        - detail
      title: ServerErrorResponse
      type: object
    SequenceReadSchema:
      properties:
        audience_table_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          title: Audience Table Id
        audience_table_name:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            List reads only: the name of audience_table_id's table, which a
            sequence in Trash keeps its status and messages columns on. Null
            when it has none, or the table is in Trash too.
          title: Audience Table Name
        audience_view_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          title: Audience View Id
        bcc_addresses:
          description: Blind copies on every email this sequence sends.
          items:
            type: string
          title: Bcc Addresses
          type: array
        cc_addresses:
          description: Addresses copied on every email this sequence sends.
          items:
            type: string
          title: Cc Addresses
          type: array
        column_mapping:
          $ref: '#/components/schemas/ColumnMappingSchema'
        connection_requests_sent:
          anyOf:
            - type: integer
            - type: 'null'
          title: Connection Requests Sent
        connections_accepted:
          anyOf:
            - type: integer
            - type: 'null'
          description: >-
            Invitations from this sequence confirmed accepted. With
            connection_requests_sent this yields the acceptance rate.
          title: Connections Accepted
        contacts_added:
          anyOf:
            - type: integer
            - type: 'null'
          description: >-
            Rollup, list reads only. None when the list's stats have never been
            built and could not be built on this request (for example, another
            request was building them). Show a zero state, not a fake 0.
          title: Contacts Added
        contacts_blocked:
          anyOf:
            - type: integer
            - type: 'null'
          description: >-
            Rollup, list reads only: the contacts under the Audience tab's
            Blocked tab (failed, bounced, in cooldown, mailbox removed, do not
            contact, in another sequence). Unreachable contacts count under In
            progress here; the Audience tab counts them under Blocked, because
            reachability is judged from the row as it reads now.
          title: Contacts Blocked
        contacts_done:
          anyOf:
            - type: integer
            - type: 'null'
          description: >-
            Rollup, list reads only: the contacts under the Audience tab's Done
            tab (finished, replied, unsubscribed, stopped, removed and the
            like).
          title: Contacts Done
        contacts_failed:
          anyOf:
            - type: integer
            - type: 'null'
          deprecated: true
          description: >-
            Deprecated, kept for API clients: every contact whose step failed
            (rollup, list reads only). Read contacts_blocked, which counts them
            with everyone else the Audience tab files under Blocked.
          title: Contacts Failed
        contacts_finished:
          anyOf:
            - type: integer
            - type: 'null'
          deprecated: true
          description: >-
            Deprecated, kept for API clients: every contact who completed the
            cadence or stopped for any reason (rollup, list reads only). Read
            contacts_done and contacts_blocked, which split them as the Audience
            tab does.
          title: Contacts Finished
        contacts_in_progress:
          anyOf:
            - type: integer
            - type: 'null'
          description: >-
            Rollup, list reads only: the contacts under the Audience tab's In
            progress, Needs approval and Paused tabs together. On a draft these
            are its contacts who start when it launches, which the list calls
            Not started. Unreachable contacts count under In progress here; the
            Audience tab counts them under Blocked, because reachability is
            judged from the row as it reads now. Since 2026-10-19 it also counts
            Needs approval and Paused contacts and a draft's waiting contacts;
            it counted only contacts moving before. None when the stats have not
            been built in this shape yet.
          title: Contacts In Progress
        contacts_not_started:
          anyOf:
            - type: integer
            - type: 'null'
          deprecated: true
          description: >-
            Deprecated, kept for API clients: a draft's contacts, who start when
            it launches (rollup, list reads only). Read contacts_in_progress,
            which on a draft counts the same contacts the list calls Not
            started.
          title: Contacts Not Started
        continuous_enrolment:
          default: false
          description: >-
            TRUE keeps the audience live: rows added to the table later enrol on
            their own, and rows that leave it stop. FALSE (the default for a new
            sequence) freezes the audience after launch; Add to sequence still
            adds rows to it by hand.
          title: Continuous Enrolment
          type: boolean
        created_at:
          format: date-time
          title: Created At
          type: string
        deleted_at:
          anyOf:
            - format: date-time
              type: string
            - type: 'null'
          description: >-
            When it went to Trash; null for a live sequence. Trash deletes it
            for good 30 days after. A launched one went paused and comes back
            paused; a draft comes back a draft.
          title: Deleted At
        edges:
          items:
            $ref: '#/components/schemas/SequenceEdgeSchema'
          title: Edges
          type: array
        email_approval_mode:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            `manual` requires approval; `confident` adds approval for uncertain
            AI-written emails; null follows the sender. There is no value
            meaning 'send automatically': a sequence can only add an approval.
          title: Email Approval Mode
        emails_sent:
          anyOf:
            - type: integer
            - type: 'null'
          title: Emails Sent
        hold:
          anyOf:
            - $ref: '#/components/schemas/SequenceListHoldSchema'
            - type: 'null'
          description: >-
            List reads only, read live on every request (never from the cached
            stats): on a running sequence nobody on which can move, the worst
            reason holding them (as GET /sequences/{id}/holds/ names it). Null
            while anybody moves and on any other status.
        id:
          format: uuid
          title: Id
          type: string
        is_favorite:
          default: false
          description: >-
            List reads only: whether the person asking starred the sequence.
            Their own, never a teammate's; always false for an API key.
          title: Is Favorite
          type: boolean
        last_synced_at:
          anyOf:
            - format: date-time
              type: string
            - type: 'null'
          description: >-
            When the audience-enrolment diff last completed. None until the
            first sync (launch runs one inline). The Audience tab shows this
            plus a manual trigger, never a background job the user cannot see.
          title: Last Synced At
        last_viewed_at:
          anyOf:
            - format: date-time
              type: string
            - type: 'null'
          description: >-
            List reads only: when the person asking last opened the sequence;
            null when they never have, and for an API key.
          title: Last Viewed At
        launched_at:
          anyOf:
            - format: date-time
              type: string
            - type: 'null'
          title: Launched At
        linkedin_approval_mode:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            `manual` requires approval; `confident` adds approval for uncertain
            AI-written LinkedIn steps; null follows the sender. There is no
            value meaning 'send automatically': a sequence can only add an
            approval.
          title: Linkedin Approval Mode
        linkedin_check_max_seconds:
          anyOf:
            - type: integer
            - type: 'null'
          deprecated: true
          description: Retired. Acceptance checks now use the service-managed interval.
          title: Linkedin Check Max Seconds
        linkedin_check_min_seconds:
          anyOf:
            - type: integer
            - type: 'null'
          deprecated: true
          description: Retired. Acceptance checks now use the service-managed interval.
          title: Linkedin Check Min Seconds
        linkedin_messages_sent:
          anyOf:
            - type: integer
            - type: 'null'
          title: Linkedin Messages Sent
        multithreading:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Multithreading
        name:
          title: Name
          type: string
        opportunity_values:
          anyOf:
            - additionalProperties:
                type: integer
              type: object
            - type: 'null'
          description: Dollars per outcome label; None = tracking off.
          title: Opportunity Values
        opt_out_footer_text:
          title: Opt Out Footer Text
          type: string
        outbound_agent_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: >-
            The sequence's outbound agent: the writer of every agent-written
            step and of its replies. Read and configure it under
            /outbound-agents/{id}/.
          title: Outbound Agent Id
        pause_reason:
          anyOf:
            - type: string
            - type: 'null'
          title: Pause Reason
        plain_text_only:
          default: true
          description: >-
            TRUE (recommended) sends no formatting: the bold, italic and link
            marks are stripped and the email reads as plain text; FALSE renders
            them. Either way the email carries an HTML part laid out line for
            line, which keeps its spacing exactly, beside a matching text part.
          title: Plain Text Only
          type: boolean
        positive:
          anyOf:
            - type: integer
            - type: 'null'
          description: Threads labelled positive (rollup, list reads only).
          title: Positive
        positive_rate:
          anyOf:
            - type: number
            - type: 'null'
          title: Positive Rate
        replies:
          anyOf:
            - type: integer
            - type: 'null'
          description: 'Distinct contacts who replied: reply_rate''s numerator.'
          title: Replies
        reply_rate:
          anyOf:
            - type: number
            - type: 'null'
          title: Reply Rate
        sender_profile_ids:
          description: >-
            Only meaningful on list reads: the sequence's senders by id, in the
            same order as sender_profile_names.
          items:
            format: uuid
            type: string
          title: Sender Profile Ids
          type: array
        sender_profile_names:
          description: 'Only meaningful on list reads: the names of the sequence''s senders.'
          items:
            type: string
          title: Sender Profile Names
          type: array
        senders_ready:
          default: true
          description: >-
            Only meaningful on list reads: False when the sequence has senders
            but none currently has a connected mailbox.
          title: Senders Ready
          type: boolean
        sending_priority:
          default: new_contacts
          description: 'Who gets scarce capacity first: new_contacts or follow_ups.'
          title: Sending Priority
          type: string
        sending_window:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Sending Window
        sending_window_problem:
          anyOf:
            - $ref: '#/components/schemas/SendingWindowProblemSchema'
            - type: 'null'
          description: >-
            Set when the saved sending_window breaks a rule a save now refuses,
            which only a window saved before those rules can. It still sends on
            it as stored: an unknown timezone is read as UTC, and no open day
            sends at any hour. Fix it by saving a valid sending_window.
        spending_limit_tenths:
          anyOf:
            - type: integer
            - type: 'null'
          title: Spending Limit Tenths
        status:
          $ref: '#/components/schemas/SequenceStatus'
        status_column_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          title: Status Column Id
        step_count:
          title: Step Count
          type: integer
        steps:
          items:
            $ref: '#/components/schemas/SequenceStepSchema-Output'
          title: Steps
          type: array
        updated_at:
          format: date-time
          title: Updated At
          type: string
      required:
        - id
        - name
        - status
        - audience_table_id
        - audience_view_id
        - column_mapping
        - status_column_id
        - sending_window
        - multithreading
        - opt_out_footer_text
        - launched_at
        - pause_reason
        - created_at
        - updated_at
        - steps
        - edges
        - step_count
      title: SequenceReadSchema
      type: object
    UnprocessableEntityIssue:
      properties:
        input:
          anyOf:
            - type: string
            - type: integer
            - type: number
            - type: boolean
            - items: {}
              type: array
            - additionalProperties: true
              type: object
          description: The user's input that caused the error.
          title: Input
        loc:
          description: >-
            The location of the error. Always contains 1 or 2 elements. The
            first element is the type of location (e.g. 'body', 'query', 'path',
            'header'). The second element is the name of the field that caused
            the error. If the error is not related to a specific field, the
            second element is not present.
          items:
            type: string
          title: Loc
          type: array
        msg:
          description: The message of the error. The error message to show to the user.
          title: Msg
          type: string
        type:
          description: >-
            The type of the error. Useful for frontend code to handle different
            types of errors.
          title: Type
          type: string
      required:
        - loc
        - msg
        - type
        - input
      title: UnprocessableEntityIssue
      type: object
    ColumnMappingSchema:
      description: >-
        Which audience columns carry a meaning, all detected from the table.


        One field per channel (email, LinkedIn) plus the company domain the

        coverage line reports on. Leave the whole object out when binding an

        audience and the columns are detected server-side. Send it only to
        correct

        a detection: a first name, a company or a last-contacted date is no
        longer

        part of this, because every column on the table is already addressable
        as a

        `{{Column name}}` variable.
      properties:
        company_domain_column_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: >-
            The account identity, reported on by the audience coverage counts.
            Unmapped, the coverage count is zero.
          title: Company Domain Column Id
        email_column_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: >-
            Where the send address is read from, and the deduplication key: two
            rows sharing an address are one contact.
          title: Email Column Id
        email_deliverability_column_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: >-
            The column holding each address's deliverability verdict, usually
            the Verify email column over the email column; detected when the
            table has one. Read only while an email column is mapped, and
            dropped without one. An address is emailed only when its verdict is
            one of `email_deliverability_results`; any other verdict skips the
            email step (LinkedIn steps still run), and an address not verified
            yet waits for its verdict. Unmapped, every address is emailed
            unverified.
          title: Email Deliverability Column Id
        email_deliverability_results:
          description: >-
            The verdicts the sequence emails: valid, catch-all, risky, unknown,
            invalid or disposable. Valid alone by default; an empty list reads
            as the default. An answer the column could not give counts as
            unknown.
          items:
            $ref: '#/components/schemas/EmailDeliverability'
          maxItems: 6
          title: Email Deliverability Results
          type: array
        linkedin_url_column_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: Required by LinkedIn steps; a row without one skips them.
          title: Linkedin Url Column Id
      title: ColumnMappingSchema
      type: object
    SequenceEdgeSchema:
      properties:
        branch:
          $ref: '#/components/schemas/SequenceEdgeBranch'
          default: default
          description: >-
            Which way the connection leaves its step. `default` is the one way
            on from an email or a LinkedIn step; a condition leaves by `yes` and
            `no`. A connection request leaves by the answer it gets: `connected`
            (accepted, or connected already) and `not_accepted` (not accepted
            within its window), plus `already_connected` when already-connected
            contacts get a branch of their own; any of them may go to the same
            step. A connection request saved with one `default` connection, or
            none, gets both branches going where it went.
        from_step_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: None = the start node.
          title: From Step Id
        to_step_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: None = an end node.
          title: To Step Id
      title: SequenceEdgeSchema
      type: object
    SequenceListHoldSchema:
      description: >-
        The one reason a running sequence's list row names while nobody on it
        can move.
      properties:
        contacts:
          description: >-
            How many contacts it holds: for approval, the cards waiting in
            Tasks, which the row names ("Needs approval: 10").
          title: Contacts
          type: integer
        long_offline:
          default: false
          description: 'For an offline browser: nothing for over a day.'
          title: Long Offline
          type: boolean
        reason:
          $ref: '#/components/schemas/SequenceHold'
        sender_name:
          anyOf:
            - type: string
            - type: 'null'
          description: 'For a LinkedIn reason: whose account it is.'
          title: Sender Name
        until:
          anyOf:
            - format: date-time
              type: string
            - type: 'null'
          description: When the reason ends on its own, where it does.
          title: Until
        window_open:
          default: true
          description: >-
            Whether the sending window was open when this was read. An offline
            browser is only worth a warning while it is (call C3).
          title: Window Open
          type: boolean
      required:
        - reason
        - contacts
      title: SequenceListHoldSchema
      type: object
    SendingWindowProblemSchema:
      description: A rule the saved sending window breaks, and where.
      properties:
        field:
          description: >-
            Where in sending_window it is, as its keys spell it: ['timezone'],
            ['days'], ['days', 'mon'], ['days', 'mon', 'start'] or
            ['min_interval_minutes']; empty when the window as a whole cannot be
            read.
          items:
            type: string
          title: Field
          type: array
        message:
          description: What is wrong and what to change, in the product's words.
          title: Message
          type: string
      required:
        - field
        - message
      title: SendingWindowProblemSchema
      type: object
    SequenceStatus:
      description: >-
        Lifecycle of a sequence.


        DRAFT until launch; RUNNING sequences are locked against structural
        edits

        (pause → edit → resume); PAUSED stops scheduling while leaving every

        enrolment exactly where it is; COMPLETED is terminal.
      enum:
        - draft
        - running
        - paused
        - completed
      title: SequenceStatus
      type: string
    SequenceStepSchema-Output:
      properties:
        agent_prompt_key:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            Read-only: the agent's slot for this step's prompt (the step's id).
            Set by the server on every agent-written step; ignored on write.
          title: Agent Prompt Key
        agent_subject:
          default: false
          description: >-
            On an agent-written email that starts a thread: the agent writes the
            subject line too, and `subject_segments` is ignored. Off, the typed
            subject is sent. Ignored on a reply and on written steps.
          title: Agent Subject
          type: boolean
        authoring:
          $ref: '#/components/schemas/StepAuthoring'
          default: written
          description: >-
            Who writes the words. 'written' sends the subject and body below;
            'agent' has the sequence's outbound agent write them for each
            contact from `prompt`, the contact's row and the workspace's
            business context, priced per contact. An email, a connection note, a
            LinkedIn message or an InMail.
        body_segments:
          items:
            $ref: '#/components/schemas/TemplateSegmentSchema'
          title: Body Segments
          type: array
        condition_kind:
          anyOf:
            - $ref: '#/components/schemas/SequenceConditionKind'
            - type: 'null'
        condition_window_days:
          anyOf:
            - maximum: 90
              minimum: 1
              type: integer
            - type: 'null'
          description: >-
            How many days the step waits for its answer. On a check that waits
            (Replied?, Email bounced?), its window. On a connection request, how
            long it waits for the request to be accepted before the contact goes
            down its `not_accepted` branch: null is saved as 14, and a change
            holds every contact already waiting to the new window.
          title: Condition Window Days
        id:
          format: uuid
          title: Id
          type: string
        kind:
          $ref: '#/components/schemas/SequenceStepKind'
        position:
          default: 0
          minimum: 0
          title: Position
          type: integer
        prompt:
          default: ''
          description: >-
            What the agent is asked to write at this step. Stored on the agent,
            not the step, and saved with the graph: this is the one way to
            change it.
          maxLength: 4000
          title: Prompt
          type: string
        reply_to_step_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          description: >-
            The earlier email step this email replies to: it goes out under that
            step's send to the contact (Re: its subject, In-Reply-To its
            Message-ID), from the mailbox that sent it. Must be an email step
            that comes before this one on the graph. Null starts a new thread.
            Only on email steps.
          title: Reply To Step Id
        requires_approval:
          default: false
          description: >-
            Hold this step for approval even when its channel would run on its
            own. One-way: true adds an approval, false never removes the one the
            channel's resolved mode already wants.
          title: Requires Approval
          type: boolean
        subject_segments:
          anyOf:
            - items:
                $ref: '#/components/schemas/TemplateSegmentSchema'
              type: array
            - type: 'null'
          description: >-
            The subject of an email that starts a thread. Ignored on a reply
            (`reply_to_step_id`), whose subject is the thread's, and on an email
            whose subject the agent writes (`agent_subject`). An email that
            starts a thread with neither fails preflight until a subject is
            added. A blank subject on an email after another one, with no
            `reply_to_step_id`, is saved as a reply to the nearest earlier
            email, which is what it used to mean.
          title: Subject Segments
        title:
          anyOf:
            - maxLength: 80
              type: string
            - type: 'null'
          description: >-
            What the step is called on its card, in the customer's words: set by
            the library campaign that laid it out, or by whoever saves the
            graph. Null names it by its place in the cadence (Opener, New angle,
            Break-up). Sending the stored title back, or leaving it out, keeps
            it while the step keeps its kind and who writes it; a different
            title renames the step, and an empty one clears the name.
          title: Title
        wait_amount:
          default: 0
          maximum: 365
          minimum: 0
          title: Wait Amount
          type: integer
        wait_unit:
          $ref: '#/components/schemas/SequenceWaitUnit'
          default: days
      required:
        - id
        - kind
      title: SequenceStepSchema
      type: object
    EmailDeliverability:
      description: >-
        The verdicts a Verify email column answers with, in the words its cells
        hold.


        The ``verify_email`` chain respells every supplier's verdict onto
        exactly

        these words (``email_verdict_canonical`` in ``table_enrichments``), so a

        sequence that reads the column compares its cells against them. Ordered

        from the safest to send to, which is the order the Audience tab lists
        them.
      enum:
        - valid
        - catch-all
        - risky
        - unknown
        - invalid
        - disposable
      title: EmailDeliverability
      type: string
    SequenceEdgeBranch:
      description: >-
        Which way an edge leaves its step.


        DEFAULT for message-step flow; YES/NO for a condition's two branches. A

        connection request leaves by the answer it got: CONNECTED (accepted, and

        already connected unless that has a branch of its own),
        ALREADY_CONNECTED

        (present only when the request splits it out) and NOT_ACCEPTED.
      enum:
        - default
        - 'yes'
        - 'no'
        - connected
        - already_connected
        - not_accepted
      title: SequenceEdgeBranch
      type: string
    SequenceHold:
      description: >-
        One reason a live contact cannot move right now, as the sequence's pages
        say it.


        The stored ``HoldReason`` and the task-derived ``WaitingOn`` each cover
        part

        of this; the LinkedIn account's own state covers the rest. This is their

        union, read at request time, so the Overview, the Audience tab, the
        header

        and the Sequences list name one reason with one word (the silent-stall

        plan, approved 2026-09-30).


        Listed worst first: the order is the order a page picks its one headline

        or banner by. The first five need a person; ``EMAIL_CHECK`` may (it ends

        by itself while the deliverability column runs); ``APPROVAL`` needs one

        but has its own row and banner already; the rest end on their own.
      enum:
        - linkedin_verify_account
        - linkedin_disconnected
        - no_mailbox
        - no_message
        - linkedin_browser_offline
        - email_check
        - approval
        - daily_cap
        - linkedin_daily_limit
        - linkedin_weekly_limit
        - window
        - writing_delayed
        - queued_to_write
      title: SequenceHold
      type: string
    StepAuthoring:
      description: >-
        Who writes an email step's words.


        WRITTEN is the default and what every step was before: the author's own

        subject and body, with variables, snippets and spintax resolved per

        contact. AGENT holds an instruction instead of a body; the whole email
        is

        written for each contact at send time from that instruction, the row and

        the workspace's written business context, and priced per contact.
      enum:
        - written
        - agent
      title: StepAuthoring
      type: string
    TemplateSegmentSchema:
      properties:
        builtin:
          anyOf:
            - $ref: '#/components/schemas/BuiltinVariable'
            - type: 'null'
        column_id:
          anyOf:
            - format: uuid
              type: string
            - type: 'null'
          title: Column Id
        kind:
          $ref: '#/components/schemas/SegmentKind'
        options:
          description: Spintax alternatives; one is chosen per contact.
          items:
            type: string
          maxItems: 20
          title: Options
          type: array
        required:
          default: true
          title: Required
          type: boolean
        text:
          default: ''
          title: Text
          type: string
      required:
        - kind
      title: TemplateSegmentSchema
      type: object
    SequenceConditionKind:
      description: >-
        The branching conditions.


        ``BOUNCED`` and ``REPLIED`` are only pickable after a message step
        exists

        earlier on the same path: enforced at save, explained in the picker.
      enum:
        - has_email
        - has_linkedin_url
        - linkedin_connected
        - bounced
        - replied
        - linkedin_invite_accepted
        - linkedin_open_profile
      title: SequenceConditionKind
      type: string
    SequenceStepKind:
      description: >-
        What a graph node does.


        The LINKEDIN_* kinds do not send anything themselves. They enqueue
        browser

        work and park the contact until it runs, because the action happens in
        the

        customer's own browser and that browser may be closed.


        Every kind here is something the product can carry out end to end. There
        is

        deliberately no phone-call or text-message kind: the engine cannot dial
        or

        text, and a step it can only hand to a person to do elsewhere is a to-do

        list wearing a sequence's clothes, not a channel this product supports.
      enum:
        - message
        - condition
        - linkedin_profile_view
        - linkedin_connection_request
        - linkedin_message
        - linkedin_inmail
        - linkedin_withdraw_invitation
        - linkedin_follow
        - linkedin_like_post
      title: SequenceStepKind
      type: string
    SequenceWaitUnit:
      enum:
        - days
        - hours
      title: SequenceWaitUnit
      type: string
    BuiltinVariable:
      description: |-
        Non-column variables the composer offers.

        Weekday variables render the *name* of the day ("Thursday") so a cadence
        can reference real days without weekly rewrites.
      enum:
        - sender_first_name
        - sender_full_name
        - sender_title
        - sender_booking_link
        - sending_domain
        - sequence_name
        - greeting
        - today
        - yesterday
        - tomorrow
        - day_plus_2
        - day_plus_3
        - day_plus_4
      title: BuiltinVariable
      type: string
    SegmentKind:
      description: One piece of a subject or body template.
      enum:
        - text
        - column
        - builtin
        - spintax
      title: SegmentKind
      type: string
  securitySchemes:
    APIKeyHeader:
      in: header
      name: X-API-Key
      type: apiKey
    HTTPBearer:
      scheme: bearer
      type: http

````

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