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

# Create Envelope

> The **Create Envelope** endpoint creates a new **sign envelope** in Nitro.

A **sign envelope** is the container for signature processes in Nitro. It can include assets such as documents, participants, signature fields, and configuration settings that define how the signing process should behave.
With the Create Envelope endpoint, you will create an empty sign envelope you can later add assets to.




## OpenAPI

````yaml https://api.gonitro.dev/openapi.json post /sign/envelopes
openapi: 3.1.0
info:
  title: Nitro Sign Public API
  description: REST API for Nitro Sign
  version: '0.1'
servers:
  - url: https://api.gonitro.dev
    description: Europe
  - url: https://api.us.gonitro.dev
    description: North America
  - url: https://api.au.gonitro.dev
    description: Australia
security:
  - bearerAuth: []
paths:
  /sign/envelopes:
    post:
      tags:
        - Sign
      summary: Create Envelope
      description: >
        The **Create Envelope** endpoint creates a new **sign envelope** in
        Nitro.


        A **sign envelope** is the container for signature processes in Nitro.
        It can include assets such as documents, participants, signature fields,
        and configuration settings that define how the signing process should
        behave.

        With the Create Envelope endpoint, you will create an empty sign
        envelope you can later add assets to.
      operationId: createEnvelope
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/EnvelopeCreate'
        required: true
      responses:
        '201':
          description: >
            When an envelope is created you will get a unique ID for it. You can
            add assets to the envelope later by referencing its unique ID using
            other endpoints in this API.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ExtendedEnvelope'
        '400':
          description: Invalid envelope or document name
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/BadRequestProblemDetail'
        '401':
          description: Unauthorized - Invalid or missing JWT token
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/UnauthorizedProblemDetail'
components:
  schemas:
    EnvelopeCreate:
      type: object
      properties:
        name:
          type: string
          description: The Envelope's name. It doesn't have to be unique.
          minLength: 1
        notification:
          $ref: '#/components/schemas/Notification'
          description: >
            The `notification` object defines the email sent to participants
            when an envelope is delivered for signing. It contains a `subject`
            and a `body` as nested parameters, and both fields support dynamic
            variables.


            **Required unless `notificationsManagedBy` is `sender`.** It is
            optional in the schema because the requirement depends on
            `notificationsManagedBy`:

            - `notificationsManagedBy` omitted or `nitro`: `notification` is
            required, with a non-empty `subject` and `body`.

            - `notificationsManagedBy` is `sender`: `notification` must be
            omitted. Nitro sends no email for this envelope, so the copy would
            never be rendered. Sending both is rejected with a `400`.


            **Dynamic Variables**

            You can personalize notification emails by referencing dynamic
            variables in the subject or body.

            Available variables:
                `envelope_name`: The name of the envelope being signed.
                `sender_name_or_email`: The sender’s name, or their email address if the name is not available.

            Syntax:

            To reference the variables, wrap them with `$()` in your message.
            Example: `$(envelope_name)`


            `notification` object example:

            ``` json

            {
                "notification": {
                    "subject": "$(sender_name_or_email) is requesting your signature",
                    "body": "Hi,\nPlease sign the $(envelope_name)\nThank you,\n$(sender_name_or_email)"
                }
            }

            ```
        mode:
          type: string
          description: >
            The Signing Mode is an enum that defines the signing order. It has
            two possible values:

            - `sequential`: Participants receive notifications one at a time, in
            the order they were added to the envelope. Each new notification is
            triggered once the previous participant has completed their signing.

            - `parallel`: All participants are notified at the same time and can
            sign the documents in the envelope independently, without waiting
            for others.
          enum:
            - sequential
            - parallel
        notificationsManagedBy:
          type: string
          description: >
            Who notifies the participants of this envelope. Two values are
            accepted:

            - `nitro` (default): Nitro sends the participant notification
            emails, as it always has.

            - `sender`: Nitro sends **no** automated email notifications to
            signers or CC recipients — including signature requests, reminders
            and signature completion notices. You distribute the signing links
            yourself, using the *List Signer Signing URLs by Envelope ID*
            endpoint and the envelope webhooks.


            When set to `sender`, the `notification` object must be omitted —
            its `subject` and `body` would never be rendered, so sending both is
            rejected with a `400`. When it is omitted or set to `nitro`, the
            `notification` object is required.


            **This setting is only available to API applications.**


            By enabling this setting, you assume full responsibility for
            notifying signers and CC recipients of pending signature requests,
            deadlines, and completed documents through your own communication
            channels. Nitro Sign will not notify these participants on your
            behalf under any circumstances while this setting is enabled.


            Depending on your use case and jurisdiction, failure to adequately
            notify signers may affect the enforceability of the resulting
            electronic signature or your compliance obligations under applicable
            e-signature laws (e.g., ESIGN Act, UETA, eIDAS). We strongly
            recommend consulting your legal or compliance team before enabling
            this setting in production.


            This setting requires SMS authentication to be configured for all
            signers on the envelope, as an additional safeguard against
            unauthorized access to signing links. Sending the envelope for
            signing fails if any signer is missing it.
          enum:
            - nitro
            - sender
      required:
        - mode
        - name
    ExtendedEnvelope:
      type: object
      properties:
        ID:
          type: string
          format: uuid
          description: >-
            A unique UUIDv4 string that identifies the envelope in the Nitro
            system.
        createdAt:
          type: string
          format: date-time
          description: UTC timestamp indicating when the envelope was created.
        lastModifiedAt:
          type: string
          format: date-time
          description: >-
            UTC timestamp indicating the last time the envelope was updated.
            Matches `createdAt` at the time of creation.
        name:
          type: string
          description: The name of the envelope.
        status:
          type: string
          description: >-
            The internal status of the envelope. Defaults to drafted on
            creation.
          enum:
            - drafted
            - sent
            - processing
            - sealed
            - rejected
            - cancelled
            - deleted
        mode:
          type: string
          description: Signing mode for the envelope.
          enum:
            - sequential
            - parallel
        notification:
          $ref: '#/components/schemas/Notification'
          description: >-
            Notification settings for the envelope. Omitted while
            `notificationsManagedBy` is `sender`: Nitro renders no copy for such
            an envelope, so it exposes none.
        notificationsManagedBy:
          type: string
          description: >-
            Who notifies the participants of this envelope: `nitro` or `sender`.
            Defaults to `nitro`.
          enum:
            - nitro
            - sender
    BadRequestProblemDetail:
      type: object
      description: Bad Request error details
      example:
        type: https://developers.gonitro.com/docs/build-nitro/errors#400-bad-request
        title: Bad Request
        status: 400
        detail: Request validation failed
        instance: /sign/envelopes
        validation_errors:
          name: must not be blank
      properties:
        type:
          type: string
          description: A URI reference that identifies the problem type
        title:
          type: string
          description: A short, human-readable summary of the problem type
        status:
          type: integer
          format: int32
          description: The HTTP status code
        detail:
          type: string
          description: A human-readable explanation specific to this occurrence
        instance:
          type: string
          description: A URI reference that identifies the specific occurrence
        extensions:
          type: object
          additionalProperties: {}
          description: Additional problem-specific properties
    UnauthorizedProblemDetail:
      type: object
      description: Unauthorized error details
      example:
        type: >-
          https://developers.gonitro.com/docs/build-nitro/errors#401-unauthorized
        title: Unauthorized
        status: 401
        detail: Missing or invalid Authorization header
        instance: /sign/envelopes
      properties:
        type:
          type: string
          description: A URI reference that identifies the problem type
        title:
          type: string
          description: A short, human-readable summary of the problem type
        status:
          type: integer
          format: int32
          description: The HTTP status code
        detail:
          type: string
          description: A human-readable explanation specific to this occurrence
        instance:
          type: string
          description: A URI reference that identifies the specific occurrence
        extensions:
          type: object
          additionalProperties: {}
          description: Additional problem-specific properties
    Notification:
      type: object
      properties:
        subject:
          type: string
          description: The subject line of the notification email.
          minLength: 1
        body:
          type: string
          description: The body content of the notification email.
          minLength: 1
      required:
        - body
        - subject
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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