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

# Send a LinkedIn message to a contact

> <small>_Requires the `contacts:operate` scope (or a broader one that includes it)._</small>

Send a one-off LinkedIn message to a contact you're already connected with, from one of your connected accounts.

Pass `sendAfter` to send it later, at most 30 days ahead; a moment already past sends now. **Coming soon (mid November 2026).** Pass `scheduleId` to send it at that schedule's next opening, from `sendAfter` when given; without either, the send is made within the request. A send for later waits on Reply's side and goes to the LinkedIn account's queue only once it is due. It answers `queued` with `sendAfter`, or `waitingForSchedule` with `estimatedSendAt`, and a `linkedin-scheduled-<id>` reference that stays the send's reference for its whole life.

**Coming soon (mid November 2026).** A send for later is not refused for the account's limits when it is accepted. Once it is due, an attempt blocked by the account's daily allowance for the action is retried, within the schedule's open hours when it has one, until `retryWindowMinutes` (90 by default) after it was due; the send then fails with the code of what blocked it, as `failureCode`.

Read the send's state with `GET /v3/direct-sends/{reference}`, or cancel it while it is `queued` or `waitingForSchedule` with `POST /v3/direct-sends/{reference}/cancel`. **Coming soon (mid November 2026).** A send for later can be cancelled until the LinkedIn account starts it, also once it waits in the account's queue.



## OpenAPI

````yaml /api-reference/bundled.yaml post /v3/contacts/{id}/send-direct-linkedin-message
openapi: 3.1.0
info:
  version: 3.0.0
  title: Reply API
  description: API for managing email sequences, contacts, and automation workflows
servers:
  - url: https://api.reply.io
security:
  - bearerAuth: []
tags:
  - name: Contacts
    description: Manage individual contacts
  - name: Contact Lists
    description: Manage contact lists and contact membership
  - name: Accounts
    description: Manage accounts (companies/organizations)
  - name: Account Lists
    description: Manage account lists and account membership
  - name: Custom Fields
    description: Manage custom contact fields
  - name: Prompt Actions
    description: Save reusable AI prompts and run them on contacts to fill custom fields
  - name: Contact Blacklist Rules
    description: Manage blacklist rules for domains, emails, and email exceptions
  - name: Live Data
    description: >-
      Find new contacts via Live Data searches and read typeahead values for the
      Live Data / Autopilot filter sidebar
  - name: Contact Enrichment
    description: >-
      Enrich contacts with emails, phone numbers, LinkedIn data, and AI-filled
      custom fields
  - name: Email Validations
    description: Estimate and schedule asynchronous email validation jobs
  - name: AI SDR Web Search
    description: Find contacts via AI-driven web search and review past searches
  - name: Sequences
    description: Manage email automation sequences
  - name: Sequence Steps
    description: Manage individual steps in sequences
  - name: Sequence Contacts
    description: Manage contacts within sequences
  - name: Sequence Folders
    description: Organize sequences into folders
  - name: Email Accounts
    description: Manage email accounts used for sending and receiving
  - name: Sequence Email Accounts
    description: Manage email accounts linked to sequences
  - name: LinkedIn Accounts
    description: Manage LinkedIn accounts for outreach
  - name: Sequence LinkedIn Accounts
    description: Manage LinkedIn accounts linked to sequences
  - name: Sequence Templates
    description: Manage sequence templates
  - name: Email Templates
    description: Manage email templates and template folders
  - name: Voices
    description: Manage cloned voices used for AI voice message steps
  - name: Schedules
    description: Manage email send schedules and timing
  - name: Holiday Calendars
    description: Manage holiday calendars for scheduling
  - name: Inbox
    description: >-
      Manage inbox threads — list/filter, read state, replies, category
      assignment, and meeting-intent flagging
  - name: Inbox Categories
    description: Manage per-team inbox thread categories and assign threads to them
  - name: Direct Outreach
    description: >-
      Send one-off outreach directly to a contact outside of any sequence —
      direct emails and LinkedIn connection requests, messages, InMails, and
      voice messages
  - name: Tasks
    description: Manage tasks and to-do items
  - name: Reports
    description: >-
      Generate and access performance reports across email, calls, tasks,
      LinkedIn, and team performance
  - name: AI SDR Sequences
    description: >-
      Manage AI SDR sequences and their AI SDR-specific settings — create, read
      settings, partial update, autopilot enable/disable/force-start, approval
      mode, sequence structure, and playbook/knowledge-base connections
  - name: AI SDR Sequence Structures
    description: >-
      Browse the sequence structures — reusable outlines of AI SDR sequence
      steps — that can be applied to AI SDR sequences
  - name: AI SDR Strategist
    description: Trigger AI Strategist runs
  - name: AI SDR Playbooks
    description: >-
      Manage AI SDR playbooks — tone, voice, and style guides applied during
      personalized message generation
  - name: AI SDR Knowledge Bases
    description: >-
      Manage AI SDR knowledge bases — collections of documents, links, reply
      handlers, and reengagement cards that inform the agent's responses
  - name: AI SDR Offers
    description: >-
      Manage AI SDR offers — bundles of company-context inputs (ICP, pain
      points, value propositions, etc.) used to personalize outreach
  - name: AI SDR Pending Approvals
    description: >-
      Review, send, regenerate, and provide feedback on AI-generated messages
      awaiting human approval
  - name: AI SDR Sequence Preview
    description: >-
      Read and regenerate per-contact previews of the messages a sequence will
      send, and provide feedback on preview messages
  - name: AI SDR Insights
    description: Read AI SDR insights for sequence contacts
  - name: AI SDR Intent Signals
    description: >-
      Read Reply industry IDs and technology slugs used in AI SDR intent-signal
      configuration (typeahead)
  - name: AI Prompts
    description: >-
      Manage the AI prompts used to configure sequence steps, and preview the
      output a prompt produces
  - name: AI SDR Learnings
    description: >-
      Manage the standing rules that shape how the AI writes — list, read,
      create, partially update and delete AI learnings
  - name: Registration
    description: Register the contact that domain purchases are filed under
  - name: Domains
    description: Find domains available to buy for outreach
  - name: Purchased Domains
    description: >-
      List the domains your team bought, with their subscription, setup and
      renewal state, and renew them
  - name: Pre-warmed Domains
    description: >-
      Find pre-warmed domains on sale, with mailboxes that are already warming,
      and list the ones your team bought
  - name: Mailboxes
    description: >-
      Add mailboxes to domains your team already bought, priced before you
      order, and reconnect them
  - name: User Account
    description: Account information and authentication verification
  - name: Teams
    description: Add existing users of your organization to its teams
  - name: Settings
    description: Manage team and user settings
  - name: Billing
    description: Subscription details and monthly active contacts usage
  - name: Rate Limits
    description: Your API rate limits, your current usage and the packages that raise them
  - name: Support Requests
    description: Raise and follow support requests with Reply's support team
  - name: Webhooks
    description: Manage webhook subscriptions and inspect delivery history
  - name: Background Jobs
    description: >-
      Track and cancel asynchronous background operations (e.g., email
      validation)
  - name: Attachments
    description: >-
      Upload file attachments used across email templates, sequence steps, and
      direct emails
paths:
  /v3/contacts/{id}/send-direct-linkedin-message:
    post:
      tags:
        - Direct Outreach
      summary: Send a LinkedIn message to a contact
      description: >-
        <small>_Requires the `contacts:operate` scope (or a broader one that
        includes it)._</small>


        Send a one-off LinkedIn message to a contact you're already connected
        with, from one of your connected accounts.


        Pass `sendAfter` to send it later, at most 30 days ahead; a moment
        already past sends now. **Coming soon (mid November 2026).** Pass
        `scheduleId` to send it at that schedule's next opening, from
        `sendAfter` when given; without either, the send is made within the
        request. A send for later waits on Reply's side and goes to the LinkedIn
        account's queue only once it is due. It answers `queued` with
        `sendAfter`, or `waitingForSchedule` with `estimatedSendAt`, and a
        `linkedin-scheduled-<id>` reference that stays the send's reference for
        its whole life.


        **Coming soon (mid November 2026).** A send for later is not refused for
        the account's limits when it is accepted. Once it is due, an attempt
        blocked by the account's daily allowance for the action is retried,
        within the schedule's open hours when it has one, until
        `retryWindowMinutes` (90 by default) after it was due; the send then
        fails with the code of what blocked it, as `failureCode`.


        Read the send's state with `GET /v3/direct-sends/{reference}`, or cancel
        it while it is `queued` or `waitingForSchedule` with `POST
        /v3/direct-sends/{reference}/cancel`. **Coming soon (mid November
        2026).** A send for later can be cancelled until the LinkedIn account
        starts it, also once it waits in the account's queue.
      operationId: SendDirectLinkedInMessage
      parameters:
        - name: id
          in: path
          required: true
          description: Contact ID
          schema:
            type: integer
            minimum: 1
        - name: Idempotency-Key
          in: header
          required: false
          description: >-
            Makes the send safe to retry. A repeat of a completed send with the
            same key and the same request answers the first answer again, with
            the same `reference`, and sends nothing. Any repeat while the first
            is still running answers 409 `directLinkedIn.idempotencyKeyInUse`;
            once it has completed, the same key with a different request answers
            409 `directLinkedIn.idempotencyKeyReused`, naming the send the key
            was first used for. A request that failed, including one that ended
            with an unexpected error, releases its key, so a repeat is a new
            attempt; after an unexpected error the first attempt may have sent,
            so check the contact's activity before repeating. `sendAfter` is
            compared as a UTC moment, so the same moment written with an offset
            or with `Z` is the same request. Keys are kept for 24 hours, per
            user, so the same key used by two users makes two sends; 1 to 255
            printable ASCII characters, and a malformed key answers 400 with the
            pointer `/Idempotency-Key`. **Coming soon (mid November 2026).** A
            header whose bytes are not valid UTF-8 is rejected by the server
            with an empty 400. In the rare event that stored keys are lost
            within those 24 hours, a repeat is treated as a new request and
            sends again.
          schema:
            type: string
            minLength: 1
            maxLength: 255
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - linkedInAccountId
                - message
              properties:
                linkedInAccountId:
                  type: integer
                  description: >-
                    ID of the LinkedIn account to send from. Must be greater
                    than 0.
                message:
                  type: string
                  maxLength: 8000
                  description: Message body text.
                sendAfter:
                  type: string
                  format: date-time
                  nullable: true
                  description: >-
                    Do not send before this UTC moment, at most 30 days ahead. A
                    moment already past sends now. **Coming soon (mid November
                    2026).** With `scheduleId`, the first opening of the
                    schedule from this moment.
                scheduleId:
                  type: integer
                  nullable: true
                  description: >-
                    **Coming soon (mid November 2026).** Send at this schedule's
                    next opening - queued for it at once when the schedule is
                    open now or opens within the next ten minutes, otherwise
                    waiting for it (`waitingForSchedule`) and handed to the
                    LinkedIn account's queue within about 10 minutes of it.
                    Holidays are skipped as the schedule says. A schedule you
                    cannot read answers 404 `directLinkedIn.scheduleNotFound`;
                    one with no active day that has a time range answers 409
                    `directLinkedIn.scheduleHasNoSlot`. A schedule emptied that
                    way while the send waits fails it with `failureCode`
                    `directLinkedIn.scheduleHasNoSlot`; a send due while its
                    schedule is closed waits for the next opening.
                useContactTimeZone:
                  type: boolean
                  nullable: true
                  description: >-
                    **Coming soon (mid November 2026).** Read the schedule in
                    the contact's time zone (`true`) or in the schedule's own
                    (`false`); absent, as the schedule is set. Only with
                    `scheduleId`. `true` for a contact with no time zone answers
                    409 `directLinkedIn.contactTimeZoneMissing`; absent, a
                    schedule set to the contact's time zone reads its own for
                    such a contact, as in a sequence.
                retryWindowMinutes:
                  type: integer
                  nullable: true
                  minimum: 1
                  maximum: 4320
                  default: 90
                  description: >-
                    **Coming soon (mid November 2026).** How long, in minutes,
                    after a send for later is due it may still go out; 90 when
                    absent, at most 3 days. An attempt blocked by the account's
                    daily allowance, or for a connection request by LinkedIn's
                    limit on the account, is retried when the block ends, or
                    every 15 minutes when its end is unknown; with `scheduleId`,
                    only within the schedule's open hours, while the window
                    keeps running. A send handed to the account's queue waits
                    there for the rest of the window. When the window ends the
                    send fails with the code of what blocked it last, or
                    `directLinkedIn.missedWindow` when nothing blocked it. Only
                    with `sendAfter` or `scheduleId`; ignored for a send made
                    now (a `sendAfter` already past).
      responses:
        '200':
          description: >-
            Message accepted. Every field is always present, `null` when it does
            not apply; read `state` first. A send made now carries its
            `linkedInActivityId` and a `linkedin-<id>` reference, and
            `sentAtUtc` is when it went out if it ran within the request,
            otherwise when it was accepted. **Coming soon (mid November 2026).**
            A send for later answers `queued` or `waitingForSchedule` with a
            `linkedin-scheduled-<id>` reference, which never changes, and
            `linkedInActivityId` and `sentAtUtc` null.
          content:
            application/json:
              schema:
                type: object
                title: Send Direct LinkedIn Response
                description: >-
                  Response returned after a direct LinkedIn action is accepted.
                  Every field is always present, `null` when it does not apply.
                required:
                  - actionType
                  - linkedInActivityId
                  - sentAtUtc
                  - reference
                  - state
                  - sendAfter
                  - estimatedSendAt
                properties:
                  actionType:
                    description: The type of LinkedIn action performed.
                    type: string
                    title: Direct LinkedIn Action Type
                    enum:
                      - connect
                      - inMail
                      - message
                      - voice
                      - aiVoice
                  linkedInActivityId:
                    type: integer
                    nullable: true
                    description: >-
                      ID of the LinkedIn activity record created for this
                      action. **Coming soon (mid November 2026).** Null for a
                      send for later (a `sendAfter` still ahead, or a
                      `scheduleId`), which has none until it is due; read it by
                      its `reference`.
                  sentAtUtc:
                    type: string
                    format: date-time
                    nullable: true
                    description: >-
                      UTC timestamp when the action was accepted, or when it
                      went out if it ran within the request. **Coming soon (mid
                      November 2026).** Null for a send for later. Read `state`
                      first; the moment a send goes out comes from `GET
                      /v3/direct-sends/{reference}`.
                  reference:
                    type: string
                    description: >-
                      The send's reference, `linkedin-<id>`, for `GET
                      /v3/direct-sends/{reference}` and its cancel. **Coming
                      soon (mid November 2026).** A send for later answers
                      `linkedin-scheduled-<id>`. A send keeps its reference for
                      its whole life. Treat it as opaque.
                  state:
                    description: >-
                      Where the send stands - `queued` when `sendAfter` lies
                      ahead, otherwise `sending`, or already `sent` or `failed`.
                      **Coming soon (mid November 2026).** `waitingForSchedule`
                      while it waits for its schedule.
                    type: string
                    title: Direct Send State
                    enum:
                      - queued
                      - waitingForSchedule
                      - sending
                      - sent
                      - failed
                      - cancelled
                  sendAfter:
                    type: string
                    format: date-time
                    nullable: true
                    description: >-
                      UTC moment after which the send is attempted - the
                      requested `sendAfter`, or when the send was accepted.
                      **Coming soon (mid November 2026).** With `scheduleId`,
                      the opening it was queued for when the schedule is open
                      now or opens within the next ten minutes; null while the
                      send waits for its schedule, and `estimatedSendAt` is set
                      then.
                  estimatedSendAt:
                    type: string
                    format: date-time
                    nullable: true
                    description: >-
                      **Coming soon (mid November 2026).** When the schedule
                      next opens, as read at acceptance, for a send left waiting
                      for it (`waitingForSchedule`); the send is handed to the
                      LinkedIn account's queue within about 10 minutes of it.
                      Null for any other send, and when the schedule does not
                      open within 30 days of the moment the send waits from (the
                      requested `sendAfter`, or the acceptance).
              examples:
                sent_now:
                  summary: Made within the request
                  value:
                    actionType: message
                    linkedInActivityId: 1044
                    sentAtUtc: '2026-05-15T10:32:00Z'
                    reference: linkedin-1044
                    state: sending
                    sendAfter: '2026-05-15T10:32:00Z'
                    estimatedSendAt: null
                queued:
                  summary: >-
                    Accepted to be sent at sendAfter — Coming soon (mid November
                    2026)
                  value:
                    actionType: message
                    linkedInActivityId: null
                    sentAtUtc: null
                    reference: linkedin-scheduled-354
                    state: queued
                    sendAfter: '2026-11-20T09:00:00Z'
                    estimatedSendAt: null
                waiting_for_schedule:
                  summary: >-
                    Accepted to wait for its schedule — Coming soon (mid
                    November 2026)
                  value:
                    actionType: message
                    linkedInActivityId: null
                    sentAtUtc: null
                    reference: linkedin-scheduled-364
                    state: waitingForSchedule
                    sendAfter: null
                    estimatedSendAt: '2026-11-03T17:00:00Z'
        '400':
          description: >-
            Validation failure on the route parameter or request body, or a
            business rule rejection.


            **Coming soon (mid November 2026).** `useContactTimeZone` without
            `scheduleId`, and `retryWindowMinutes` outside 1 to 4320 or without
            `sendAfter` or

            `scheduleId`, are validation failures with the field's pointer.


            | `code` | Meaning |

            |---|---|

            | `directLinkedIn.messageTooLong` | Message body exceeds the allowed
            length |

            | `directLinkedIn.missingVariables` | Message template contains
            unresolved variables |

            | `directLinkedIn.unknown` | The send failed |


            When the send was made in this request and failed, the problem also
            names it: `reference`, `state` (`failed`)

            and `sendAfter`. A refusal before any send was made is the usual
            problem, without them.
          content:
            application/problem+json:
              schema:
                oneOf:
                  - allOf:
                      - allOf:
                          - type: object
                            title: Problem Details
                            description: >-
                              Bare RFC 9457 problem-details envelope. Returned
                              by middleware-level errors

                              that don't carry domain context: 401 Unauthorized
                              (auth middleware),

                              429 Too Many Requests (rate-limit middleware), and
                              route-level 404 / 405 /

                              415 (framework middleware).


                              Business and validation responses extend this
                              envelope and add additional

                              fields — see `business-problem.model.yaml` (adds
                              `code` slug) and

                              `validation-problem.model.yaml` (adds `errors[]`
                              array).
                            properties:
                              title:
                                type: string
                                description: Short, human-readable summary of the problem.
                              status:
                                type: integer
                                description: HTTP status code.
                                minimum: 100
                                maximum: 599
                              detail:
                                type: string
                                description: >-
                                  Human-readable explanation specific to this
                                  occurrence.
                          - type: object
                            properties:
                              errors:
                                type: array
                                description: >-
                                  List of field-level validation errors. Always
                                  non-empty when this

                                  envelope is returned. Each entry pins a single
                                  offending field

                                  via JSON Pointer plus a sanitized detail
                                  string.
                                items:
                                  type: object
                                  title: Validation Error
                                  description: A single field-level validation error.
                                  properties:
                                    pointer:
                                      type: string
                                      description: >-
                                        JSON Pointer (RFC 6901) to the offending
                                        field — e.g.

                                        `/steps/0/subject`.


                                        * An empty string (`""`) means the error
                                        applies to the whole
                                          request body (e.g. body is missing or unparseable).
                                        * For route or query parameter failures
                                        the pointer is the parameter
                                          name (e.g. `id`, `top`).
                                      example: /steps/0/subject
                                    detail:
                                      type: string
                                      description: >-
                                        Sanitized, human-readable explanation of
                                        this field's error. One of a

                                        small set of templates — `"Field is
                                        required."`, `"Value has an

                                        invalid type."`, `"Value has an invalid
                                        format."`, `"Request body is

                                        not valid JSON."`, `"The request body is
                                        required and cannot be

                                        empty."` — or a FluentValidator message
                                        on body endpoints.
                                      example: Field is required.
                        title: Validation Problem
                        description: >-
                          Input-validation error response at 400. Returned when
                          the request body

                          fails binding, FluentValidator rules, or when
                          route/query parameter

                          attribute validation (`[Range]`, `[Required]`) fails.
                          Route, query, and

                          body errors are combined into a single `errors[]`
                          array — clients should

                          not assume one error per request.
                      - example:
                          title: Validation failed
                          status: 400
                          detail: The request body contains validation errors.
                          errors:
                            - pointer: /name
                              detail: Field is required.
                  - allOf:
                      - allOf:
                          - type: object
                            title: Problem Details
                            description: >-
                              Bare RFC 9457 problem-details envelope. Returned
                              by middleware-level errors

                              that don't carry domain context: 401 Unauthorized
                              (auth middleware),

                              429 Too Many Requests (rate-limit middleware), and
                              route-level 404 / 405 /

                              415 (framework middleware).


                              Business and validation responses extend this
                              envelope and add additional

                              fields — see `business-problem.model.yaml` (adds
                              `code` slug) and

                              `validation-problem.model.yaml` (adds `errors[]`
                              array).
                            properties:
                              title:
                                type: string
                                description: Short, human-readable summary of the problem.
                              status:
                                type: integer
                                description: HTTP status code.
                                minimum: 100
                                maximum: 599
                              detail:
                                type: string
                                description: >-
                                  Human-readable explanation specific to this
                                  occurrence.
                          - type: object
                            properties:
                              code:
                                type: string
                                description: >-
                                  Stable, machine-readable error slug in the
                                  form

                                  `"<resource>.<variant>"`.


                                  * `resource` is the camelCased domain — e.g.
                                  `sequence`,
                                    `contact`, `inboxThread`, `blacklistDomainRule`.
                                  * `variant` is the camelCased specific failure
                                  mode — e.g.
                                    `notFound`, `forbidden`, `duplicateName`, `globalRuleReadOnly`.

                                  Use `code` for programmatic error handling;
                                  use `detail` for

                                  user-facing messages. Slugs are stable across
                                  server-side enum

                                  reorderings and never change meaning under a
                                  given resource.
                                pattern: ^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)+$
                                example: sequence.notFound
                        title: Business Problem
                        description: >-
                          Domain error response carrying a stable, namespaced
                          error slug.

                          Emitted for most 4xx responses (business 400, 403,
                          404, 409, …) and

                          for 503 when a downstream dependency is unavailable.
                      - example:
                          title: Bad Request
                          status: 400
                          detail: Pagination parameters are invalid.
                          code: sequence.invalidPagination
                  - allOf:
                      - allOf:
                          - type: object
                            title: Problem Details
                            description: >-
                              Bare RFC 9457 problem-details envelope. Returned
                              by middleware-level errors

                              that don't carry domain context: 401 Unauthorized
                              (auth middleware),

                              429 Too Many Requests (rate-limit middleware), and
                              route-level 404 / 405 /

                              415 (framework middleware).


                              Business and validation responses extend this
                              envelope and add additional

                              fields — see `business-problem.model.yaml` (adds
                              `code` slug) and

                              `validation-problem.model.yaml` (adds `errors[]`
                              array).
                            properties:
                              title:
                                type: string
                                description: Short, human-readable summary of the problem.
                              status:
                                type: integer
                                description: HTTP status code.
                                minimum: 100
                                maximum: 599
                              detail:
                                type: string
                                description: >-
                                  Human-readable explanation specific to this
                                  occurrence.
                          - type: object
                            properties:
                              code:
                                type: string
                                description: >-
                                  Stable, machine-readable error slug in the
                                  form

                                  `"<resource>.<variant>"`.


                                  * `resource` is the camelCased domain — e.g.
                                  `sequence`,
                                    `contact`, `inboxThread`, `blacklistDomainRule`.
                                  * `variant` is the camelCased specific failure
                                  mode — e.g.
                                    `notFound`, `forbidden`, `duplicateName`, `globalRuleReadOnly`.

                                  Use `code` for programmatic error handling;
                                  use `detail` for

                                  user-facing messages. Slugs are stable across
                                  server-side enum

                                  reorderings and never change meaning under a
                                  given resource.
                                pattern: ^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)+$
                                example: sequence.notFound
                        title: Business Problem
                        description: >-
                          Domain error response carrying a stable, namespaced
                          error slug.

                          Emitted for most 4xx responses (business 400, 403,
                          404, 409, …) and

                          for 503 when a downstream dependency is unavailable.
                      - type: object
                        properties:
                          reference:
                            type: string
                            nullable: true
                            description: >-
                              The reference of the send that was made and
                              failed. Read it with `GET
                              /v3/direct-sends/{reference}`.
                            example: email-48215
                          state:
                            allOf:
                              - type: string
                                title: Direct Send State
                                description: >-
                                  Where a direct send stands.


                                  | Value | Meaning |

                                  |---|---|

                                  | `queued` | Accepted and waiting for its
                                  moment; it can still be cancelled. |

                                  | `waitingForSchedule` | Accepted and waiting
                                  for its schedule to open, more than ten
                                  minutes after acceptance; `estimatedSendAt`
                                  says when. A schedule open sooner queues the
                                  send at once (`queued`). It can still be
                                  cancelled. |

                                  | `sending` | Being sent right now - for a
                                  LinkedIn send, handed to the account's queue
                                  and waiting or running there. It can no longer
                                  be cancelled, except a LinkedIn send for later
                                  that waits in the account's queue and has not
                                  been started. |

                                  | `sent` | Gone out. |

                                  | `failed` | Did not go out, or its outcome is
                                  unknown; `failureCode` and `failureReason` say
                                  why. |

                                  | `cancelled` | Cancelled while queued; it
                                  will not go out. |
                                enum:
                                  - queued
                                  - waitingForSchedule
                                  - sending
                                  - sent
                                  - failed
                                  - cancelled
                            nullable: true
                            description: The state of that send as answered, `failed`.
                          sendAfter:
                            type: string
                            format: date-time
                            nullable: true
                            description: UTC moment after which that send was attempted.
                          missingVariables:
                            type: array
                            items:
                              type: string
                            description: >-
                              With `code` `contact.missingVariables`, the
                              variables the template uses that have no value for
                              the contact. Absent otherwise.
                    title: Direct Send Problem
                    description: >-
                      The problem of a send that was made and then failed. It
                      names the send, so it can be read by its `reference`.
              example:
                title: Validation failed
                status: 400
                detail: The request body contains validation errors.
                errors:
                  - pointer: /message
                    detail: '''message'' must not be empty.'
        '401':
          description: >-
            Unauthorized. The response body is empty; check the
            `WWW-Authenticate` header for the expected scheme.
          content:
            application/problem+json:
              schema:
                allOf:
                  - type: object
                    title: Problem Details
                    description: >-
                      Bare RFC 9457 problem-details envelope. Returned by
                      middleware-level errors

                      that don't carry domain context: 401 Unauthorized (auth
                      middleware),

                      429 Too Many Requests (rate-limit middleware), and
                      route-level 404 / 405 /

                      415 (framework middleware).


                      Business and validation responses extend this envelope and
                      add additional

                      fields — see `business-problem.model.yaml` (adds `code`
                      slug) and

                      `validation-problem.model.yaml` (adds `errors[]` array).
                    properties:
                      title:
                        type: string
                        description: Short, human-readable summary of the problem.
                      status:
                        type: integer
                        description: HTTP status code.
                        minimum: 100
                        maximum: 599
                      detail:
                        type: string
                        description: >-
                          Human-readable explanation specific to this
                          occurrence.
                  - example:
                      title: Unauthorized
                      status: 401
                      detail: Authentication credentials are missing or invalid.
        '403':
          description: LinkedIn direct actions feature is disabled for this account.
          content:
            application/problem+json:
              schema:
                allOf:
                  - allOf:
                      - type: object
                        title: Problem Details
                        description: >-
                          Bare RFC 9457 problem-details envelope. Returned by
                          middleware-level errors

                          that don't carry domain context: 401 Unauthorized
                          (auth middleware),

                          429 Too Many Requests (rate-limit middleware), and
                          route-level 404 / 405 /

                          415 (framework middleware).


                          Business and validation responses extend this envelope
                          and add additional

                          fields — see `business-problem.model.yaml` (adds
                          `code` slug) and

                          `validation-problem.model.yaml` (adds `errors[]`
                          array).
                        properties:
                          title:
                            type: string
                            description: Short, human-readable summary of the problem.
                          status:
                            type: integer
                            description: HTTP status code.
                            minimum: 100
                            maximum: 599
                          detail:
                            type: string
                            description: >-
                              Human-readable explanation specific to this
                              occurrence.
                      - type: object
                        properties:
                          code:
                            type: string
                            description: >-
                              Stable, machine-readable error slug in the form

                              `"<resource>.<variant>"`.


                              * `resource` is the camelCased domain — e.g.
                              `sequence`,
                                `contact`, `inboxThread`, `blacklistDomainRule`.
                              * `variant` is the camelCased specific failure
                              mode — e.g.
                                `notFound`, `forbidden`, `duplicateName`, `globalRuleReadOnly`.

                              Use `code` for programmatic error handling; use
                              `detail` for

                              user-facing messages. Slugs are stable across
                              server-side enum

                              reorderings and never change meaning under a given
                              resource.
                            pattern: ^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)+$
                            example: sequence.notFound
                    title: Business Problem
                    description: >-
                      Domain error response carrying a stable, namespaced error
                      slug.

                      Emitted for most 4xx responses (business 400, 403, 404,
                      409, …) and

                      for 503 when a downstream dependency is unavailable.
                  - example:
                      title: Forbidden
                      status: 403
                      detail: You do not have permission to access this resource.
                      code: sequence.forbidden
              example:
                title: Forbidden
                status: 403
                detail: >-
                  LinkedIn direct actions feature is not enabled for this
                  account.
                code: directLinkedIn.featureDisabled
        '404':
          description: >-
            Contact, LinkedIn profile, or LinkedIn account not found. **Coming
            soon (mid November 2026).** A `scheduleId` that names no schedule
            you can read answers `directLinkedIn.scheduleNotFound`. The same
            failure on `POST /v3/contacts/{id}/send-direct-email` answers
            `contact.scheduleNotFound`, so a client handling both channels
            should expect both codes.
          content:
            application/problem+json:
              schema:
                allOf:
                  - allOf:
                      - type: object
                        title: Problem Details
                        description: >-
                          Bare RFC 9457 problem-details envelope. Returned by
                          middleware-level errors

                          that don't carry domain context: 401 Unauthorized
                          (auth middleware),

                          429 Too Many Requests (rate-limit middleware), and
                          route-level 404 / 405 /

                          415 (framework middleware).


                          Business and validation responses extend this envelope
                          and add additional

                          fields — see `business-problem.model.yaml` (adds
                          `code` slug) and

                          `validation-problem.model.yaml` (adds `errors[]`
                          array).
                        properties:
                          title:
                            type: string
                            description: Short, human-readable summary of the problem.
                          status:
                            type: integer
                            description: HTTP status code.
                            minimum: 100
                            maximum: 599
                          detail:
                            type: string
                            description: >-
                              Human-readable explanation specific to this
                              occurrence.
                      - type: object
                        properties:
                          code:
                            type: string
                            description: >-
                              Stable, machine-readable error slug in the form

                              `"<resource>.<variant>"`.


                              * `resource` is the camelCased domain — e.g.
                              `sequence`,
                                `contact`, `inboxThread`, `blacklistDomainRule`.
                              * `variant` is the camelCased specific failure
                              mode — e.g.
                                `notFound`, `forbidden`, `duplicateName`, `globalRuleReadOnly`.

                              Use `code` for programmatic error handling; use
                              `detail` for

                              user-facing messages. Slugs are stable across
                              server-side enum

                              reorderings and never change meaning under a given
                              resource.
                            pattern: ^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)+$
                            example: sequence.notFound
                    title: Business Problem
                    description: >-
                      Domain error response carrying a stable, namespaced error
                      slug.

                      Emitted for most 4xx responses (business 400, 403, 404,
                      409, …) and

                      for 503 when a downstream dependency is unavailable.
                  - example:
                      title: Not Found
                      status: 404
                      detail: The requested resource was not found.
                      code: sequence.notFound
              examples:
                schedule_not_found:
                  summary: Schedule not found — Coming soon (mid November 2026)
                  value:
                    title: Not Found
                    status: 404
                    detail: Schedule with ID 7 not found
                    code: directLinkedIn.scheduleNotFound
                contact_not_found:
                  summary: Contact not found
                  value:
                    title: Not Found
                    status: 404
                    detail: Contact with ID 42 not found.
                    code: directLinkedIn.contactNotFound
                no_linkedin_profile:
                  summary: Contact has no LinkedIn profile URL
                  value:
                    title: Not Found
                    status: 404
                    detail: This contact does not have a LinkedIn profile URL set.
                    code: directLinkedIn.noLinkedInProfile
                linkedin_account_not_found:
                  summary: LinkedIn account not found
                  value:
                    title: Not Found
                    status: 404
                    detail: LinkedIn account not found or not accessible.
                    code: directLinkedIn.linkedInAccountNotFound
        '409':
          description: >-
            Conflict — the LinkedIn account state or connection status prevents
            the action, the `Idempotency-Key` cannot be used for this request,
            or the send cannot wait for the schedule.


            | `code` | Meaning |

            |---|---|

            | `directLinkedIn.linkedInAccountInactive` | Specified LinkedIn
            account is inactive |

            | `directLinkedIn.invalidCookie` | LinkedIn account session cookie
            is invalid |

            | `directLinkedIn.notConnected` | Not connected with this contact on
            LinkedIn |

            | `directLinkedIn.idempotencyKeyInUse` | A request with this
            `Idempotency-Key` is still running |

            | `directLinkedIn.idempotencyKeyReused` | This `Idempotency-Key` was
            already used for a different request |

            | `directLinkedIn.contactTimeZoneMissing` | **Coming soon (mid
            November 2026).** `useContactTimeZone` is `true`, and the contact
            has no time zone |

            | `directLinkedIn.scheduleHasNoSlot` | **Coming soon (mid November
            2026).** The schedule has no active day with a time range, so it
            never opens |


            A reused key names the send it was first used for; `state` is as
            answered at acceptance, read `GET /v3/direct-sends/{reference}` for
            the current one.
          content:
            application/problem+json:
              schema:
                oneOf:
                  - allOf:
                      - allOf:
                          - type: object
                            title: Problem Details
                            description: >-
                              Bare RFC 9457 problem-details envelope. Returned
                              by middleware-level errors

                              that don't carry domain context: 401 Unauthorized
                              (auth middleware),

                              429 Too Many Requests (rate-limit middleware), and
                              route-level 404 / 405 /

                              415 (framework middleware).


                              Business and validation responses extend this
                              envelope and add additional

                              fields — see `business-problem.model.yaml` (adds
                              `code` slug) and

                              `validation-problem.model.yaml` (adds `errors[]`
                              array).
                            properties:
                              title:
                                type: string
                                description: Short, human-readable summary of the problem.
                              status:
                                type: integer
                                description: HTTP status code.
                                minimum: 100
                                maximum: 599
                              detail:
                                type: string
                                description: >-
                                  Human-readable explanation specific to this
                                  occurrence.
                          - type: object
                            properties:
                              code:
                                type: string
                                description: >-
                                  Stable, machine-readable error slug in the
                                  form

                                  `"<resource>.<variant>"`.


                                  * `resource` is the camelCased domain — e.g.
                                  `sequence`,
                                    `contact`, `inboxThread`, `blacklistDomainRule`.
                                  * `variant` is the camelCased specific failure
                                  mode — e.g.
                                    `notFound`, `forbidden`, `duplicateName`, `globalRuleReadOnly`.

                                  Use `code` for programmatic error handling;
                                  use `detail` for

                                  user-facing messages. Slugs are stable across
                                  server-side enum

                                  reorderings and never change meaning under a
                                  given resource.
                                pattern: ^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)+$
                                example: sequence.notFound
                        title: Business Problem
                        description: >-
                          Domain error response carrying a stable, namespaced
                          error slug.

                          Emitted for most 4xx responses (business 400, 403,
                          404, 409, …) and

                          for 503 when a downstream dependency is unavailable.
                      - example:
                          title: Conflict
                          status: 409
                          detail: A resource with this name already exists.
                          code: sequence.duplicateName
                  - allOf:
                      - allOf:
                          - type: object
                            title: Problem Details
                            description: >-
                              Bare RFC 9457 problem-details envelope. Returned
                              by middleware-level errors

                              that don't carry domain context: 401 Unauthorized
                              (auth middleware),

                              429 Too Many Requests (rate-limit middleware), and
                              route-level 404 / 405 /

                              415 (framework middleware).


                              Business and validation responses extend this
                              envelope and add additional

                              fields — see `business-problem.model.yaml` (adds
                              `code` slug) and

                              `validation-problem.model.yaml` (adds `errors[]`
                              array).
                            properties:
                              title:
                                type: string
                                description: Short, human-readable summary of the problem.
                              status:
                                type: integer
                                description: HTTP status code.
                                minimum: 100
                                maximum: 599
                              detail:
                                type: string
                                description: >-
                                  Human-readable explanation specific to this
                                  occurrence.
                          - type: object
                            properties:
                              code:
                                type: string
                                description: >-
                                  Stable, machine-readable error slug in the
                                  form

                                  `"<resource>.<variant>"`.


                                  * `resource` is the camelCased domain — e.g.
                                  `sequence`,
                                    `contact`, `inboxThread`, `blacklistDomainRule`.
                                  * `variant` is the camelCased specific failure
                                  mode — e.g.
                                    `notFound`, `forbidden`, `duplicateName`, `globalRuleReadOnly`.

                                  Use `code` for programmatic error handling;
                                  use `detail` for

                                  user-facing messages. Slugs are stable across
                                  server-side enum

                                  reorderings and never change meaning under a
                                  given resource.
                                pattern: ^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)+$
                                example: sequence.notFound
                        title: Business Problem
                        description: >-
                          Domain error response carrying a stable, namespaced
                          error slug.

                          Emitted for most 4xx responses (business 400, 403,
                          404, 409, …) and

                          for 503 when a downstream dependency is unavailable.
                      - type: object
                        properties:
                          reference:
                            type: string
                            nullable: true
                            description: >-
                              The reference of the send the `Idempotency-Key`
                              was first used for.
                            example: email-48213
                          state:
                            allOf:
                              - type: string
                                title: Direct Send State
                                description: >-
                                  Where a direct send stands.


                                  | Value | Meaning |

                                  |---|---|

                                  | `queued` | Accepted and waiting for its
                                  moment; it can still be cancelled. |

                                  | `waitingForSchedule` | Accepted and waiting
                                  for its schedule to open, more than ten
                                  minutes after acceptance; `estimatedSendAt`
                                  says when. A schedule open sooner queues the
                                  send at once (`queued`). It can still be
                                  cancelled. |

                                  | `sending` | Being sent right now - for a
                                  LinkedIn send, handed to the account's queue
                                  and waiting or running there. It can no longer
                                  be cancelled, except a LinkedIn send for later
                                  that waits in the account's queue and has not
                                  been started. |

                                  | `sent` | Gone out. |

                                  | `failed` | Did not go out, or its outcome is
                                  unknown; `failureCode` and `failureReason` say
                                  why. |

                                  | `cancelled` | Cancelled while queued; it
                                  will not go out. |
                                enum:
                                  - queued
                                  - waitingForSchedule
                                  - sending
                                  - sent
                                  - failed
                                  - cancelled
                            nullable: true
                            description: >-
                              The state of that send as answered when it was
                              accepted. Read `GET /v3/direct-sends/{reference}`
                              for the current one.
                          sendAfter:
                            type: string
                            format: date-time
                            nullable: true
                            description: >-
                              UTC moment after which that send is attempted, as
                              answered when it was accepted.
                    title: Idempotency Key Reused Problem
                    description: >-
                      The 409 of a send repeated under an `Idempotency-Key`
                      already used for a different request. It names the send
                      the key was first used for.
              examples:
                not_connected:
                  summary: Not connected with this contact
                  value:
                    title: Conflict
                    status: 409
                    detail: You are not connected with this contact on LinkedIn.
                    code: directLinkedIn.notConnected
                linkedin_account_inactive:
                  summary: LinkedIn account is inactive
                  value:
                    title: Conflict
                    status: 409
                    detail: The specified LinkedIn account is inactive.
                    code: directLinkedIn.linkedInAccountInactive
                idempotency_key_reused:
                  summary: Idempotency-Key already used for a different request
                  value:
                    title: Conflict
                    status: 409
                    detail: >-
                      This Idempotency-Key was already used for a different
                      request, the send named by reference.
                    code: directLinkedIn.idempotencyKeyReused
                    reference: linkedin-48213
                    state: queued
                    sendAfter: '2026-11-03T09:00:00Z'
        '429':
          description: >-
            Rate limit reached.


            | `code` | Meaning |

            |---|---|

            | `directLinkedIn.dailyLimitReached` | Daily message limit reached |

            | `directLinkedIn.weeklyLimitReached` | Weekly message limit reached
            |


            **Coming soon (mid November 2026).** A send for later (a `sendAfter`
            still ahead, or a `scheduleId`) never answers these: it is accepted,
            and once due a

            blocked attempt is retried within its retry window.
          headers:
            Retry-After:
              description: Seconds to wait before retrying
              schema:
                type: integer
                minimum: 1
          content:
            application/problem+json:
              schema:
                allOf:
                  - type: object
                    title: Problem Details
                    description: >-
                      Bare RFC 9457 problem-details envelope. Returned by
                      middleware-level errors

                      that don't carry domain context: 401 Unauthorized (auth
                      middleware),

                      429 Too Many Requests (rate-limit middleware), and
                      route-level 404 / 405 /

                      415 (framework middleware).


                      Business and validation responses extend this envelope and
                      add additional

                      fields — see `business-problem.model.yaml` (adds `code`
                      slug) and

                      `validation-problem.model.yaml` (adds `errors[]` array).
                    properties:
                      title:
                        type: string
                        description: Short, human-readable summary of the problem.
                      status:
                        type: integer
                        description: HTTP status code.
                        minimum: 100
                        maximum: 599
                      detail:
                        type: string
                        description: >-
                          Human-readable explanation specific to this
                          occurrence.
              examples:
                daily_limit_reached:
                  summary: Daily limit reached
                  value:
                    title: Too Many Requests
                    status: 429
                    detail: The daily LinkedIn message limit has been reached.
                    code: directLinkedIn.dailyLimitReached
                weekly_limit_reached:
                  summary: Weekly limit reached
                  value:
                    title: Too Many Requests
                    status: 429
                    detail: The weekly LinkedIn message limit has been reached.
                    code: directLinkedIn.weeklyLimitReached
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Authenticate every request with a Bearer token. Pass your Reply API key
        in the

        `Authorization` header:


        ```

        Authorization: Bearer <your-api-key>

        ```


        Get your API key from the Reply dashboard: **Settings → API Key**.

````

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