Source: https://cli.nylas.com/guides/manage-email-signatures-cli

# Manage Email Signatures from the CLI

You want every email your scripts and tools send to carry the same footer, without pasting HTML into each command. This guide stores reusable signatures, lists and inspects them, updates a footer in one place, and appends the right one to any send by ID.

Written by [Nick Barraclough](https://cli.nylas.com/authors/nick-barraclough) Product Manager

Reviewed by [Qasim Muhammad](https://cli.nylas.com/authors/qasim-muhammad)

Updated June 9, 2026

> **TL;DR:** Store a signature once with [`nylas email signatures create`](https://cli.nylas.com/docs/commands), then append it to any send by passing `--signature-id` to `nylas email send`. Edit the footer in one place and every future send picks it up — but one storage detail decides whether the same signature works across two accounts, and it's in the grant-scope section below.

## How do I store a reusable email signature?

You store a signature with `nylas email signatures create`, which takes a required `--name` and an HTML body. The command returns a signature ID you reuse on every send, so the footer lives in one place instead of being pasted into dozens of scripts. The body accepts inline HTML or a file.

```bash
nylas email signatures create \
  --name "Support team" \
  --body '<p>Best,<br>The Support Team<br><a href="https://example.com">example.com</a></p>'
```

For anything longer than one line, keep the markup in a file and pass `--body-file`. A typical corporate footer with a logo, address, and disclaimer runs 15 to 30 lines of HTML, which is unreadable as a single shell string. A file keeps it in version control next to the rest of your tooling.

```bash
nylas email signatures create \
  --name "Sales" \
  --body-file ./signatures/sales.html
```

## How do I list and inspect stored signatures?

List every stored signature for the connected account with `nylas email signatures list`, and pull the full HTML of one with `nylas email signatures show` plus its ID. Adding `--json` turns either command into machine-readable output you can pipe to `jq`. The list shows 2 fields per row, the ID and the name, while `show` returns the full stored HTML.

```bash
# List all signatures (IDs and names)
nylas email signatures list

# Show one signature's full HTML body
nylas email signatures show sig_8f21c

# Grab just the ID of the signature named "Sales"
nylas email signatures list --json | jq -r '.[] | select(.name=="Sales") | .id'
```

The `jq` one-liner resolves a human-readable name to its opaque ID in a single step, so a deploy script never hard-codes an ID that could change between environments. Resolving by name keeps the same script working across a staging account and a production account that hold different signature IDs.

## How do I append a signature when sending email?

Append a stored signature to any outgoing message by passing `--signature-id` to `nylas email send`. The CLI fetches the stored HTML and attaches it to the body at send time, so the footer stays identical across every message without you re-typing a single tag. One flag replaces a copy-paste step on each send.

```bash
nylas email send \
  --to customer@example.com \
  --subject "Re: your ticket" \
  --body "<p>Your issue is resolved.</p>" \
  --signature-id sig_8f21c \
  --yes
```

Because the body is HTML or plain text, the footer renders inline below your message. The `--yes` flag skips the confirmation prompt so an unattended cron job or CI step sends without blocking. Per [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322), a footer is just part of the message body, not a separate header, which is why a stored signature is appended to the body rather than set as metadata on the envelope.

## How do I update or delete a signature?

Change a footer in one place with `nylas email signatures update` and the signature ID. Every send that references that ID picks up the new HTML on the next message, so rotating a phone number or legal disclaimer across 200 automated emails is a single command instead of a find-and-replace across your codebase.

```bash
# Swap in a new footer (e.g. updated office address)
nylas email signatures update sig_8f21c --body-file ./signatures/sales-2026.html

# Rename without touching the body
nylas email signatures update sig_8f21c --name "Sales (EMEA)"

# Remove a signature you no longer use
nylas email signatures delete sig_8f21c --yes
```

The `delete` subcommand takes `--yes` for unattended cleanup. A deleted ID is gone immediately, so any send still referencing it will fail — grep your scripts for the ID before removing a signature that production jobs depend on.

## Why are signatures scoped per account?

Stored signatures belong to a single grant, the Nylas term for one connected account, so a signature created under your support inbox is not visible to your sales inbox. Each signature ID is unique to its grant. To use the same footer across two accounts you create it twice, once per grant, and track the two IDs separately.

```bash
# Target a specific grant by passing the grant ID (or email) after the flags
nylas email signatures create \
  --name "Shared footer" \
  --body-file ./signatures/shared.html \
  sales@example.com

# List signatures for that same grant
nylas email signatures list sales@example.com
```

This per-grant model matches how the providers store native signatures. [Gmail signatures](https://support.google.com/mail/answer/8395) are set per address in account settings, and Microsoft 365 stores signatures on the individual mailbox via the [Graph message resource](https://learn.microsoft.com/en-us/graph/api/resources/message). Keeping CLI-managed signatures grant-scoped means a footer you create here behaves the same way an end user would expect from the provider.

## Next steps

- [Automate Customer Onboarding Emails](https://cli.nylas.com/guides/customer-onboarding-emails-cli) — Run a multi-day onboarding sequence from a signup hook with nylas…
- [Manage email templates from the CLI](https://cli.nylas.com/guides/email-templates-cli) — pair a stored signature with a reusable, variable-driven body
- [Send email with hosted templates](https://cli.nylas.com/guides/send-email-with-templates-cli) — render a template and append a signature in one send
- [Extract signatures from received email](https://cli.nylas.com/guides/email-signature-extraction-cli) — the read side: parse contact details out of inbound footers
- [Send email from the terminal](https://cli.nylas.com/guides/send-email-from-terminal) — the full send command, flags, and HTML body basics
- [Tag emails with metadata](https://cli.nylas.com/guides/tag-emails-with-metadata-cli) — correlate signed sends with a request or campaign ID
- [Command reference](https://cli.nylas.com/docs/commands) — every flag, subcommand, and example
- [Gmail signature settings](https://support.google.com/mail/answer/8395) — how Google stores signatures per address
- [Microsoft Graph message resource](https://learn.microsoft.com/en-us/graph/api/resources/message) — the mailbox model behind Outlook signatures
- [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322) — the internet message format that defines the body a footer lives in