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

# List destinations

> Your delivery destinations. Secret fields read as `********`.



## OpenAPI

````yaml /openapi.json get /destinations
openapi: 3.1.0
info:
  title: Filecheck API
  version: 1.1.0
  description: >-
    The Filecheck REST API. Submit files as jobs and fetch results, and set up
    your account: workflows, upload rules, preflight profiles, connectors,
    optimize presets, delivery destinations, product mappings, storefront
    settings and webhooks. All requests are authenticated server-side with your
    secret key (`sk_live_…`).
servers:
  - url: https://api.filecheck.io
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Jobs
    description: >-
      Submit files for preflight, fixing, optimization, validation and previews,
      and read the results.
  - name: Uploads
    description: Presigned credentials to upload large files directly.
  - name: Orders
    description: Attach jobs to commerce orders.
  - name: Workflows
    description: >-
      What happens to a customer's files for a product: the intake rule that
      checks them on upload, the processing streams, proofing, merging and
      delivery. Products in your store map to a workflow.
  - name: Rules
    description: >-
      Upload rules: which files a product accepts (kinds, MIME types, how many),
      which preflight profile checks each kind, and what happens when a file
      fails. A workflow's intake points at one rule.
  - name: Profiles
    description: >-
      Preflight profiles: the checks run on a file (size, bleed, resolution,
      colour, fonts…) with their thresholds, severities and automatic fixes. PDF
      profiles check PDFs (and vector and office files once converted); raster
      profiles check images.
  - name: Connectors
    description: >-
      Connectors wire a product page to the Element: what the shopper chose
      (size, page count, sides, finishing) adjusts the rule's size checks for
      that upload, and what FileCheck measured in the file (page count, size,
      area) can fill the page's own inputs so the store prices from the real
      file. The cart plugins store the chosen connector per product.
  - name: Optimize presets
    description: >-
      Saved optimize settings (compression, downsampling, colour conversion)
      that optimize steps can use.
  - name: Destinations
    description: >-
      Where finished files are delivered: SFTP and FTP hotfolders, S3 buckets,
      webhooks. Workflows list the destinations they deliver to. Secrets are
      write-only.
  - name: Products
    description: >-
      Which workflow each product in your store uses. The storefront Element
      opens the mapped workflow on the product page.
  - name: Settings
    description: >-
      How the storefront Element appears on your product pages: where it mounts,
      the add-to-cart button it guards, display mode and theme.
  - name: Webhooks
    description: >-
      HTTP callbacks for job, proof, account and billing events, signed with
      X-FileCheck-Signature.
paths:
  /destinations:
    get:
      tags:
        - Destinations
      summary: List destinations
      description: Your delivery destinations. Secret fields read as `********`.
      operationId: listDestinations
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
                properties:
                  destinations:
                    type: array
                    items:
                      allOf:
                        - $ref: '#/components/schemas/Destination'
                        - $ref: '#/components/schemas/RecordFields'
        '401':
          description: Missing or invalid key
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  schemas:
    Destination:
      title: Destination
      description: >-
        Where a job's finished, print-ready files go once the job completes
        successfully. A destination is a reusable Library record: a workflow
        lists the destinations it delivers to in
        workflow.delivery.destinationIds (and only delivers while
        workflow.delivery.enabled is not false), and one destination can serve
        any number of workflows. `kind` picks the transport and `params` holds
        that transport's settings: email (download links mailed out), webhook (a
        JSON POST with download links, e.g. into Zapier), or one of the
        hotfolder kinds s3, sftp and ftp, which copy the files themselves into a
        folder the print shop's prepress or MIS system watches. Delivery runs
        once per job, after the job reaches done (never for previews or failed
        jobs); each destination is tried once and a failure on one does not stop
        the others. Files are named after the product (e.g. Business_Cards.pdf,
        or Business_Cards-1.pdf, Business_Cards-2.pdf when a job has several).
        Secret params (sftp/ftp password, sftp privateKey and passphrase,
        webhook headerValue) are write-only: send them as plain strings and they
        are encrypted on save; they read back masked as ********, and sending
        ******** back unchanged keeps the stored value. Use the destination test
        action to send a sample delivery (a one-page Sample_Product.pdf for
        order TEST-1001) through the real transport before pointing a workflow
        at it. Changing `kind` on an existing destination: also null out the old
        kind's params (JSON Merge Patch keeps keys you don't send).
      type: object
      additionalProperties: false
      required:
        - kind
      properties:
        kind:
          type: string
          enum:
            - email
            - s3
            - webhook
            - sftp
            - ftp
          description: >-
            The transport. email: mails download links (no files attached) to an
            address, by default the shopper who placed the order. webhook: POSTs
            a JSON envelope with download links to a URL. s3: writes the files
            into an Amazon S3 bucket. sftp: uploads over SSH (SFTP). ftp:
            uploads over FTP or FTPS. s3, sftp and ftp are hotfolder kinds: they
            accept path tokens and metadata sidecars.
        title:
          type: string
          maxLength: 200
          description: >-
            Display name in the dashboard and in delivery logs, e.g. "Prepress
            hotfolder (SFTP)". Optional; the dashboard falls back to the kind
            plus host, bucket or address.
        description:
          type: string
          maxLength: 1000
          description: >-
            A note for the print shop: what this destination feeds and who owns
            the receiving end.
        params:
          type: object
          description: >-
            The settings for `kind`; each kind accepts only its own keys. email:
            to, cc, bcc, replyTo, subject, attachMetadata, includeMetadata,
            templateId, linkExpiryHours. webhook: url (required), headerName,
            headerValue (secret), includeLinks, linkExpiryHours, meta. s3:
            bucket (required), region, access, roleArn, externalId, acl, prefix,
            plus the sidecar fields. sftp: host and username (required), port,
            password and/or privateKey (secrets, one required), passphrase
            (secret), path, plus the sidecar fields. ftp: host (required), port,
            username, password (secret), secure, path, plus the sidecar fields.
            Sidecar fields (s3/sftp/ftp): sidecar, sidecarFormat,
            sidecarTemplate, sidecarExt, includeFullReport.
        secretsSet:
          type: object
          additionalProperties: false
          properties:
            password:
              type: boolean
            privateKey:
              type: boolean
            passphrase:
              type: boolean
            headerValue:
              type: boolean
          description: >-
            Dashboard display flags saying which secret params hold a value (so
            the editor can show "set" without the secret). Not used for delivery
            and not authoritative; omit it, the dashboard derives it.
        schemaVersion:
          type: integer
          minimum: 1
          description: >-
            Record format version written by the dashboard editor (currently 1).
            Omit it.
        tags:
          type: array
          maxItems: 50
          items:
            type: string
            minLength: 1
            maxLength: 64
          description: Free-form labels for organising the Library. Not used for delivery.
      allOf:
        - if:
            properties:
              kind:
                const: email
            required:
              - kind
          then:
            properties:
              params:
                $ref: '#/components/schemas/Destination/definitions/emailParams'
        - if:
            properties:
              kind:
                const: s3
            required:
              - kind
          then:
            required:
              - params
            properties:
              params:
                $ref: '#/components/schemas/Destination/definitions/s3Params'
        - if:
            properties:
              kind:
                const: webhook
            required:
              - kind
          then:
            required:
              - params
            properties:
              params:
                $ref: '#/components/schemas/Destination/definitions/webhookParams'
        - if:
            properties:
              kind:
                const: sftp
            required:
              - kind
          then:
            required:
              - params
            properties:
              params:
                $ref: '#/components/schemas/Destination/definitions/sftpParams'
        - if:
            properties:
              kind:
                const: ftp
            required:
              - kind
          then:
            required:
              - params
            properties:
              params:
                $ref: '#/components/schemas/Destination/definitions/ftpParams'
      definitions:
        secret:
          description: >-
            A write-only credential. Send the plaintext as a string; it is
            encrypted on save and reads back as ********. The stored, encrypted
            form is an object { "enc": "..." }; it only appears when a record is
            re-validated with the secret left untouched, so never construct one
            yourself. To remove a secret, send null.
          anyOf:
            - type: string
              minLength: 1
              maxLength: 16384
            - $ref: '#/components/schemas/Destination/definitions/sealedSecret'
        sealedSecret:
          type: object
          additionalProperties: false
          required:
            - enc
          description: >-
            A secret as stored: encrypted by FileCheck on save. Kept unchanged
            when a write leaves the secret alone; never construct one yourself.
          properties:
            enc:
              type: string
              minLength: 1
              description: The encrypted value.
        emailAddress:
          type: string
          format: email
          maxLength: 254
        linkExpiryHours:
          type: integer
          minimum: 1
          maximum: 168
          default: 24
          description: >-
            How long the download links stay valid, in hours (1 to 168, i.e. at
            most 7 days). Not editable in the dashboard; a later save of this
            destination from the dashboard editor drops it back to the 24-hour
            default.
        hostname:
          type: string
          minLength: 1
          maxLength: 253
          pattern: ^[a-zA-Z0-9]([a-zA-Z0-9.-]*[a-zA-Z0-9])?$
        port:
          type: integer
          minimum: 1
          maximum: 65535
        remotePath:
          type: string
          maxLength: 1024
          description: >-
            Folder layout on the receiving end, as a static folder or a template
            with {tokens}. Without tokens it is a root folder and files land in
            <path>/orders/<orderId>/<file> (or <path>/jobs/<jobId>/<file> when
            the job has no order). With any {token} the template IS the whole
            layout and the orders/ folder is not added. Tokens ({name} or
            {{name}}): {orderId}, {jobId}, {jobName}, {sku}, {productId},
            {product} (product name), {itemId} (order line item), {quantity},
            {fileId} (alias {taskId}), {customer} (customer email), {filename}
            (e.g. Business_Cards.pdf), {basename} (filename without extension),
            {ext}, {n} (file number 1, 2, ...), {date} (YYYYMMDD, UTC), {yyyy},
            {mm}, {dd}, {rand} (8 random hex chars). Values are made path-safe
            (characters other than letters, digits, _ . - and spaces are
            dropped, spaces become _, max 80 characters), and an empty or
            unknown token drops its folder level. If the template has neither
            {filename} nor {basename}, the filename is appended, so
            "/hotfolder/{orderId}/{sku}" writes
            hotfolder/ORD-1001/SKU-42/Business_Cards.pdf and
            "/in/{orderId}_{basename}.{ext}" names the file itself
            (in/ORD-1001_Business_Cards.pdf).
        sidecar:
          type: boolean
          default: false
          description: >-
            Also deliver a metadata file next to each print file, uploaded after
            it so a hotfolder watching for the sidecar always finds a complete
            print file. Named like the print file with the sidecar extension
            (Business_Cards.pdf gets Business_Cards.json). Off when omitted; the
            dashboard turns it on for new hotfolder destinations.
        sidecarFormat:
          type: string
          enum:
            - json
            - custom
          default: json
          description: >-
            json: FileCheck's JSON envelope (generated time, job, order with
            customer and shipping address, product with sku and quantity, file,
            and the preflight summary, evaluation and findings). custom: the
            text of sidecarTemplate with tokens filled in, for an MIS that
            expects its own XML, CSV or ticket format. Only used when sidecar is
            true.
        sidecarTemplate:
          type: string
          minLength: 1
          maxLength: 20000
          description: >-
            Body of a custom sidecar (sidecarFormat custom), e.g. <order
            id="{orderId}"><sku>{sku}</sku><qty>{quantity}</qty></order>. Takes
            every path token plus {customerName}, {orderStatus}, {currency},
            {total}, {pages} (page count), {minDpi} (lowest effective image
            DPI), {maxTac} (max ink coverage %), {spotColors}, {verdict} (pass,
            warn or fail), {passCount}, {warnCount}, {failCount}. Values are
            inserted raw (spaces kept), and XML-escaped when sidecarExt is xml
            or the template starts with <. Unknown tokens become empty.
        sidecarExt:
          type: string
          minLength: 1
          maxLength: 16
          pattern: ^[A-Za-z0-9_.]+$
          description: >-
            File extension for the sidecar, without the dot, e.g. xml, csv, txt,
            jdf. Defaults to json for the JSON format and txt for a custom
            template. xml is sent as application/xml, csv as text/csv, anything
            else from a custom template as text/plain.
        includeFullReport:
          type: boolean
          default: false
          description: >-
            Also deliver the complete preflight report JSON next to each print
            file (Business_Cards.report.json). Only takes effect when sidecar is
            true and the job ran a preflight.
        hotfolderRules:
          if:
            properties:
              sidecarFormat:
                const: custom
            required:
              - sidecarFormat
          then:
            required:
              - sidecarTemplate
        emailParams:
          type: object
          additionalProperties: false
          description: >-
            Email delivery: one message per job with a download link per file
            (files are never attached). Links go through FileCheck's download
            host and stay valid for linkExpiryHours. Sent from FileCheck's mail
            sender, or the account's own SMTP server when one is configured in
            settings.
          properties:
            to:
              $ref: '#/components/schemas/Destination/definitions/emailAddress'
              description: >-
                Recipient address. Leave it out and the email goes to the job's
                customer email, i.e. the shopper who placed the order, not the
                print shop; set it to the shop's production inbox to notify the
                shop instead. The destination test needs either this or the
                caller's own address.
            cc:
              $ref: '#/components/schemas/Destination/definitions/emailAddress'
              description: One address to copy on every delivery email.
            bcc:
              $ref: '#/components/schemas/Destination/definitions/emailAddress'
              description: >-
                One address to blind-copy on every delivery email, e.g. an
                archive inbox.
            replyTo:
              $ref: '#/components/schemas/Destination/definitions/emailAddress'
              description: >-
                Where replies go. Defaults to FileCheck's sender address. Not
                editable in the dashboard; a later save from the dashboard
                editor drops it.
            subject:
              type: string
              minLength: 1
              maxLength: 300
              description: >-
                Subject line. Tokens: {orderId}, {jobId}, {jobName}, {product},
                {customer} (customer email), {name} (account holder's name).
                Default: "Your print files {orderId} are ready".
            attachMetadata:
              type: boolean
              default: false
              description: >-
                Attach a JSON file with the order, product and per-file
                preflight metadata (order-<orderId>-metadata.json). Off when
                omitted; the dashboard turns it on for new email destinations.
            includeMetadata:
              type: boolean
              default: false
              description: >-
                Add an order and preflight summary table (order, product, SKU,
                quantity, preflight verdict per file) under the download links
                in the default email body. Ignored when templateId supplies the
                body.
            templateId:
              type: string
              minLength: 1
              maxLength: 128
              description: >-
                Id of one of the account's own email templates (Library >
                Emails) to use as the body instead of FileCheck's default. The
                template's HTML and text bodies take the subject tokens plus
                {links}. Not editable in the dashboard's destination editor; a
                later save from it drops this field.
            linkExpiryHours:
              $ref: '#/components/schemas/Destination/definitions/linkExpiryHours'
              default: 24
        s3Params:
          type: object
          additionalProperties: false
          required:
            - bucket
          description: >-
            Amazon S3 hotfolder: each file is written as an object in the print
            shop's bucket. FileCheck writes either by assuming a role in the
            shop's AWS account (access role: the shop creates a role whose trust
            policy allows FileCheck's AWS account, from the destination setup
            action, with the condition sts:ExternalId = externalId, and grants
            it s3:PutObject and s3:PutObjectAcl on
            arn:aws:s3:::<bucket>/<prefix>/*) or with its own credentials
            (access policy: the shop's bucket policy grants FileCheck's account
            those two actions).
          allOf:
            - $ref: '#/components/schemas/Destination/definitions/hotfolderRules'
            - if:
                properties:
                  access:
                    const: role
                required:
                  - access
              then:
                required:
                  - roleArn
                  - externalId
            - if:
                required:
                  - roleArn
                not:
                  properties:
                    access:
                      const: policy
                  required:
                    - access
              then:
                required:
                  - externalId
          properties:
            bucket:
              type: string
              pattern: ^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$
              description: >-
                Bucket name only (no s3:// and no path), e.g.
                acme-prepress-inbox.
            region:
              type: string
              pattern: ^[a-z]{2}(-[a-z]+)+-\d$
              description: >-
                The bucket's AWS region, e.g. us-east-1. Defaults to
                eu-central-1 (FileCheck's own region), so set it whenever the
                bucket lives elsewhere or writes will fail.
            access:
              type: string
              enum:
                - role
                - policy
              description: >-
                How FileCheck gets write access. role (recommended): assume
                roleArn with externalId. policy: the bucket policy grants
                FileCheck's AWS account directly; roleArn is then ignored.
                Omitted: behaves as role when roleArn is set and as policy when
                it is not.
            roleArn:
              type: string
              pattern: ^arn:aws:iam::\d{12}:role/.+$
              maxLength: 2048
              description: >-
                ARN of the IAM role in the shop's account that FileCheck
                assumes, e.g. arn:aws:iam::123456789012:role/filecheck-delivery.
                Required with access role.
            externalId:
              type: string
              minLength: 2
              maxLength: 1224
              pattern: ^[\w+=,.@:/-]+$
              description: >-
                The secret-ish value the role's trust policy requires as
                sts:ExternalId, guarding against other FileCheck accounts using
                the same role. Generate a random, unguessable value (the
                dashboard uses fcx_ followed by 24 hex characters), give it to
                the shop's AWS admin for the trust policy, and never reuse it
                across shops. Changing it requires updating the role. Required
                with access role.
            acl:
              type: string
              enum:
                - bucket-owner-full-control
                - private
                - bucket-owner-read
              description: >-
                Canned ACL set on each object. Omit it for the bucket default;
                buckets with ACLs disabled (the AWS default since 2023) reject
                any ACL except bucket-owner-full-control. With access policy,
                bucket-owner-full-control makes sure the shop owns the delivered
                files.
            prefix:
              $ref: '#/components/schemas/Destination/definitions/remotePath'
              description: >-
                Key prefix (folder) inside the bucket; leading and trailing
                slashes are ignored. Without tokens, objects land at
                <prefix>/orders/<orderId>/<file> (or
                <prefix>/jobs/<jobId>/<file>). With any {token} the prefix is
                the whole key layout. Tokens: {orderId}, {jobId}, {jobName},
                {sku}, {productId}, {product}, {itemId}, {quantity}, {fileId},
                {customer}, {filename}, {basename}, {ext}, {n}, {date}
                (YYYYMMDD), {yyyy}, {mm}, {dd}, {rand}; values are made
                path-safe, empty tokens drop their folder level, and the
                filename is appended unless {filename} or {basename} is used.
                Example: "hotfolder/{date}/{orderId}".
            sidecar:
              $ref: '#/components/schemas/Destination/definitions/sidecar'
              default: false
            sidecarFormat:
              $ref: '#/components/schemas/Destination/definitions/sidecarFormat'
              default: json
            sidecarTemplate:
              $ref: '#/components/schemas/Destination/definitions/sidecarTemplate'
            sidecarExt:
              $ref: '#/components/schemas/Destination/definitions/sidecarExt'
            includeFullReport:
              $ref: '#/components/schemas/Destination/definitions/includeFullReport'
              default: false
        webhookParams:
          type: object
          additionalProperties: false
          required:
            - url
          description: >-
            Webhook delivery: one JSON POST per job to url, 10-second timeout,
            no retries. Body: { event: "job.delivered" ("destination.test" for a
            test), jobId, orderId, customerEmail, product { itemId, productId,
            sku, name, quantity }, files [ { name, mimeType, taskId, url } ],
            meta }. The file urls are signed download links valid for
            linkExpiryHours. Use this to reach Dropbox, Google Drive, Box or
            OneDrive through a Zapier or Make catch hook.
          dependencies:
            headerValue:
              - headerName
          properties:
            url:
              type: string
              format: uri
              pattern: ^https?://
              maxLength: 2048
              description: >-
                The endpoint that receives the POST. Use https: the body carries
                download links to the customer's files.
            headerName:
              type: string
              pattern: ^[A-Za-z0-9-]{1,64}$
              description: >-
                Name of one extra request header for authenticating the call,
                e.g. Authorization or X-Api-Key. Sent only when headerValue is
                set.
            headerValue:
              $ref: '#/components/schemas/Destination/definitions/secret'
              description: >-
                Value of the headerName header, e.g. "Bearer abc123". Secret:
                send plaintext, it is encrypted on save and reads back as
                ********; the stored form is { "enc": "..." }.
            includeLinks:
              type: boolean
              default: true
              description: >-
                Include the files array with download links. Set false to send
                only the job, order and product details.
            linkExpiryHours:
              $ref: '#/components/schemas/Destination/definitions/linkExpiryHours'
              default: 24
            meta:
              type: object
              description: >-
                Free-form JSON object copied as-is into every payload as meta,
                e.g. { "source": "filecheck", "shop": "acme" }, for routing on
                the receiving side. Any keys are allowed.
        sftpParams:
          type: object
          additionalProperties: false
          required:
            - host
            - username
          description: >-
            SFTP hotfolder: files are uploaded over SSH, creating folders as
            needed. Authenticate with password or privateKey (at least one).
          allOf:
            - $ref: '#/components/schemas/Destination/definitions/hotfolderRules'
            - anyOf:
                - required:
                    - password
                - required:
                    - privateKey
          dependencies:
            passphrase:
              - privateKey
          properties:
            host:
              $ref: '#/components/schemas/Destination/definitions/hostname'
              description: >-
                Server host name or IPv4 address only, e.g. sftp.printer.example
                (no sftp:// and no port).
            port:
              $ref: '#/components/schemas/Destination/definitions/port'
              default: 22
              description: SSH port. Default 22.
            username:
              type: string
              minLength: 1
              maxLength: 256
              description: Login user name.
            password:
              $ref: '#/components/schemas/Destination/definitions/secret'
              description: >-
                Login password. Secret: send plaintext, it is encrypted on save
                and reads back as ********; the stored form is { "enc": "..." }.
            privateKey:
              description: >-
                Private key for key-based login: the full text of an OpenSSH,
                PEM or PuTTY private key, line breaks included ("-----BEGIN
                OPENSSH PRIVATE KEY-----\n..."), never the public key. Secret:
                encrypted on save, reads back as ********; the stored form is {
                "enc": "..." }.
              anyOf:
                - type: string
                  maxLength: 16384
                  pattern: >-
                    ^\s*(-----BEGIN [A-Z0-9 ]*PRIVATE
                    KEY-----|PuTTY-User-Key-File-[23]:)
                - $ref: '#/components/schemas/Destination/definitions/sealedSecret'
            passphrase:
              $ref: '#/components/schemas/Destination/definitions/secret'
              description: >-
                Passphrase that unlocks privateKey, if the key is encrypted.
                Secret: encrypted on save, reads back as ********.
            path:
              $ref: '#/components/schemas/Destination/definitions/remotePath'
              description: >-
                Folder on the server, measured from the server's root
                ("incoming" and "/incoming" both mean /incoming), created if
                missing. Without tokens, files land in
                <path>/orders/<orderId>/<file> (or <path>/jobs/<jobId>/<file>).
                With any {token} the path is the whole layout. Tokens:
                {orderId}, {jobId}, {jobName}, {sku}, {productId}, {product},
                {itemId}, {quantity}, {fileId}, {customer}, {filename},
                {basename}, {ext}, {n}, {date} (YYYYMMDD), {yyyy}, {mm}, {dd},
                {rand}; values are made path-safe, empty tokens drop their
                folder level, and the filename is appended unless {filename} or
                {basename} is used. Example: "/hotfolder/{orderId}/{sku}".
            sidecar:
              $ref: '#/components/schemas/Destination/definitions/sidecar'
              default: false
            sidecarFormat:
              $ref: '#/components/schemas/Destination/definitions/sidecarFormat'
              default: json
            sidecarTemplate:
              $ref: '#/components/schemas/Destination/definitions/sidecarTemplate'
            sidecarExt:
              $ref: '#/components/schemas/Destination/definitions/sidecarExt'
            includeFullReport:
              $ref: '#/components/schemas/Destination/definitions/includeFullReport'
              default: false
        ftpParams:
          type: object
          additionalProperties: false
          required:
            - host
          description: >-
            FTP hotfolder: files are uploaded over FTP, or explicit FTPS when
            secure is true, creating folders as needed.
          allOf:
            - $ref: '#/components/schemas/Destination/definitions/hotfolderRules'
          properties:
            host:
              $ref: '#/components/schemas/Destination/definitions/hostname'
              description: >-
                Server host name or IPv4 address only, e.g. ftp.printer.example
                (no ftp:// and no port).
            port:
              $ref: '#/components/schemas/Destination/definitions/port'
              default: 21
              description: FTP control port. Default 21.
            username:
              type: string
              minLength: 1
              maxLength: 256
              description: >-
                Login user name. Omit only for an anonymous FTP server (logs in
                as anonymous).
            password:
              $ref: '#/components/schemas/Destination/definitions/secret'
              description: >-
                Login password. Secret: send plaintext, it is encrypted on save
                and reads back as ********; the stored form is { "enc": "..." }.
            secure:
              type: boolean
              default: false
              description: >-
                Use explicit FTPS (AUTH TLS on the normal port). Leave false for
                plain FTP; implicit FTPS on port 990 is not supported.
            path:
              $ref: '#/components/schemas/Destination/definitions/remotePath'
              description: >-
                Folder relative to the directory the FTP login starts in,
                created if missing. Without tokens, files land in
                <path>/orders/<orderId>/<file> (or <path>/jobs/<jobId>/<file>).
                With any {token} the path is the whole layout. Tokens:
                {orderId}, {jobId}, {jobName}, {sku}, {productId}, {product},
                {itemId}, {quantity}, {fileId}, {customer}, {filename},
                {basename}, {ext}, {n}, {date} (YYYYMMDD), {yyyy}, {mm}, {dd},
                {rand}; values are made path-safe, empty tokens drop their
                folder level, and the filename is appended unless {filename} or
                {basename} is used. Example: "/hotfolder/{orderId}/{sku}".
            sidecar:
              $ref: '#/components/schemas/Destination/definitions/sidecar'
              default: false
            sidecarFormat:
              $ref: '#/components/schemas/Destination/definitions/sidecarFormat'
              default: json
            sidecarTemplate:
              $ref: '#/components/schemas/Destination/definitions/sidecarTemplate'
            sidecarExt:
              $ref: '#/components/schemas/Destination/definitions/sidecarExt'
            includeFullReport:
              $ref: '#/components/schemas/Destination/definitions/includeFullReport'
              default: false
    RecordFields:
      type: object
      properties:
        id:
          type: string
          description: The record id.
        source:
          type: string
          enum:
            - domain
            - store
          description: '`domain`: yours. `store`: a built-in catalog record.'
        customized:
          type: boolean
          description: >-
            Your own copy of a built-in record, under the same id. Revert drops
            it.
        draft:
          type: boolean
          description: Present and true on an unpublished draft.
        draftExpiresAt:
          type: string
          format: date-time
          description: When an unpublished draft is deleted.
        created:
          type: integer
          description: Unix time (seconds).
        modified:
          type: integer
          description: Unix time (seconds).
    Error:
      type: object
      properties:
        error:
          type: boolean
          const: true
        code:
          type: string
          description: >-
            Machine-readable reason, such as validation_failed,
            invalid_reference, not_found, in_use, draft_reference.
        message:
          type: string
        param:
          type: string
          description: >-
            The field at fault, as a dotted path (intake.ruleId,
            accepts.0.preflight.profileId).
        details:
          type: array
          description: Every problem found, or the records that block a delete.
          items:
            type: object
            additionalProperties: true
        requestId:
          type: string
          description: Quote it to support.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Your secret key as a bearer token, e.g. `Authorization: Bearer
        sk_live_…`. Secret keys are server-side only.

````

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