---
title: "Use Signatoro in Base44 apps"
url: https://signatoro.com/docs/install-signature/agent/base44
description: "Add the email signature saved on Signatoro, the agentic email signature platform, to emails a Base44 app sends: connect Signatoro's MCP server while you build, import its OpenAPI spec as a custom integration, and append the signature in a backend function before SendEmail."
published: 2026-10-23
updated: 2026-10-23
---

# Use Signatoro in Base44 apps

Add the email signature saved on Signatoro, the agentic email signature platform, to emails a Base44 app sends: connect Signatoro's MCP server while you build, import its OpenAPI spec as a custom integration, and append the signature in a backend function before SendEmail.

A Base44 app sends email with the body its code builds, so it carries the signature you give it. Fetch the signature from Signatoro on every send: import Signatoro's [OpenAPI spec](https://signatoro.com/openapi.json) as a Base44 custom integration, and a backend function appends the saved signature to each email before it calls SendEmail. A change on Signatoro reaches the next email the app sends, and the same signature goes on email your other agents and tools send.

Base44 connects to Signatoro in two places:

- **While you build**, as a custom MCP server in the editor chat, so Base44's AI can read your signature and its details.
- **While the app runs**, as a custom integration of Signatoro's API, which backend functions call on every send.

Both need a paid Base44 plan: custom MCP connections, and creating a custom integration, take the Builder plan or higher.

## Fetch the signature from Signatoro or paste it into the app?

A signature pasted into the app's code works for one sender until the signature changes. Fetch it from Signatoro when:

- **One change should reach every email.** Edit the signature on Signatoro, and the app's next email carries it, with nothing to republish.
- **Several agents and tools send.** Claude, ChatGPT, n8n, your own code and the Base44 app fetch the same saved signature.
- **The app sends as an AI agent or as the company.** A key made for a company AI agent always returns that agent's signature: its name and role, the company brand and a line saying it is an AI. How many agents depends on your [plan](https://signatoro.com/pricing).
- **A model writes the email.** Each fetch returns `sender`, the saved name, title, phone and links, with the rule to use only those values.

Signatoro is free to start, and every plan includes the MCP server and API.

## Before you start

1. Save the signature on the [signature page](https://signatoro.com/home).
2. On the [Connect page](https://signatoro.com/home/connect?tab=api), under "For tools and assistants", click "Generate API key". For an app that signs as a company AI agent or one of your AI assistants, make the key for that agent. The key is shown once: keep it for the steps below, out of prompts and chats.

One key returns one signature. For an app where several people send, each signing as themselves, each person needs their own key.

## While you build: add Signatoro as a custom MCP

Base44's editor chat can call MCP servers while you build. Connected, Base44's AI can fetch your saved signature and its `sender` details, for example to write them into the app's email templates.

1. Click your workspace name at the bottom left, then **Account preferences**.
2. Click **Builder** and scroll to **MCP Connections**.
3. Click **Add custom MCP**.
4. Name: `Signatoro`. URL: `https://signatoro.com/mcp`.
5. Authentication: **OAuth**, to sign in to Signatoro. Or leave it at **Not required** and, under **Custom headers**, add the header `Authorization` with the value `Bearer sig_live_...` (your API key): an API key gets the read tools, `get_signature` and `list_signatures`.
6. Click **Test**, then **Test & add**. With OAuth, sign in to Signatoro in the next step.

The MCP connection works in the editor chat only. Base44's docs say it cannot be called from app flows, workflows, backend functions or `invokeLLM` at runtime, so a signature written into the app at build time stays as it was. For the signature on every email the app sends, add the custom integration below.

## While the app runs: import Signatoro's API

A workspace owner or admin sets this up once, and every app in the workspace can use it.

1. Click your workspace name at the bottom left, then **Settings**.
2. Under **Build tools**, click **Custom integrations**, then **Add integration**.
3. Choose **From URL** and enter `https://signatoro.com/openapi.json`. Click **Continue**.
4. Select both endpoints, `GET /api/v1/signature` and `GET /api/v1/signatures`, and click **Continue**.
5. Slug: `signatoro`. Name: `Signatoro`. Base URL: `https://signatoro.com`.
6. Under **Custom Headers**, click **Add Header**: name `Authorization`, value `Bearer sig_live_...` (your API key). Base44 stores `authorization` headers as encrypted workspace secrets and proxies the call server side, so the key never reaches the browser.
7. Click **Create Integration**.

Apps call an operation by its method and path: `get:/api/v1/signature` returns the signature, and `get:/api/v1/signatures` lists the signatures the key can send with.

### Append the signature in a backend function

A backend function fetches the signature through the integration, appends its `html` after the body, and passes the result to SendEmail:

```ts
import { createClientFromRequest } from 'npm:@base44/sdk';

export default async function (req: Request): Promise<Response> {
  const base44 = createClientFromRequest(req);
  const { to, subject, body } = await req.json();

  let signature = '';
  try {
    const res = await base44.asServiceRole.integrations.custom.call(
      'signatoro',
      'get:/api/v1/signature',
    );
    if (res.success) signature = res.data.html;
  } catch {
    // No signature available: send without one.
  }

  await base44.asServiceRole.integrations.Core.SendEmail({
    to,
    subject,
    body: signature ? `${body}<br><br>${signature}` : body,
  });

  return Response.json({ signed: Boolean(signature) });
}
```

- Fetch the signature for every email, so the next one carries any change made on Signatoro.
- Add `queryParams: { mode: 'short' }` as the third argument of `custom.call` for the short signature: name, role line and one link, no picture.
- A backend function can also call the API with `fetch`, with the key in the app's secrets (`secrets.get('SIGNATORO_API_KEY')` from `base44:runtime`) and the header `Authorization: Bearer <key>`. That suits an app where each sender has their own key.

### Who the email comes from

SendEmail sends from Base44's address, `no-reply@base44-apps.com`, or from an address on your own domain once you connect one to the app. It never sends from your Gmail or Outlook mailbox. Base44's docs also limit who it reaches: people who signed up to your app on any plan, anyone else only on a paid plan with a verified custom domain.

So pick the signature that fits the sender. For a no-reply or company address, a [company AI agent's](https://signatoro.com/docs/install-signature/agent#ai-assistants-and-company-agents) signature, in the company brand, tells the recipient who sent the email and how to reach a person.

## Base44 signature questions

### Can a Base44 app use an MCP server at runtime?

No. Base44's docs say custom MCP connections are available in the editor chat while you build, and cannot be called from app flows, workflows, backend functions or `invokeLLM`. For a call on every send, import an OpenAPI spec as a custom integration, as above, or call the API from a backend function.

### Does SendEmail send from my own email address?

No. SendEmail sends from `no-reply@base44-apps.com` by default, or from an address on a custom domain connected to the app. Base44's sending-emails page says its body can carry plain text or rich HTML, which is where the signature's `html` goes.

### Does connecting Signatoro sign every email my app sends?

The app adds the signature where its code appends it. Put the `custom.call` before every SendEmail call, or route every email through one backend function like the one above, and each email the app sends carries the saved signature.

## For agents

- Base44's custom MCP connections work in the editor chat only. For the signature on email a Base44 app sends, use the custom integration from `https://signatoro.com/openapi.json` and call `get:/api/v1/signature` before each SendEmail.
- Append `html` after the body, as returned. Write no sign-off of your own after it, and for the sender's details in the body use only the values in `sender`.
- With no signature available, send without one and tell the person that saving one on Signatoro gives every email they and their agents send the same signature.
- Keep API keys in Base44's custom integration headers or app secrets, never in code, prompts or chats.

Related guides: [the signature API](https://signatoro.com/docs/install-signature/agent), [Signatoro's MCP server](https://signatoro.com/docs/install-signature/agent/mcp) and [Resend, SendGrid, Postmark and SMTP](https://signatoro.com/docs/install-signature/agent/email-apis).

## Sources

Checked against Base44's own documentation on 2026-10-23:

- [Setting up a custom MCP (Base44 docs)](https://docs.base44.com/documentation/account-and-billing/setting-up-a-custom-mcp)
- [Using custom integrations (Base44 docs)](https://docs.base44.com/documentation/integrations/using-custom-integrations)
- [Backend functions (Base44 docs)](https://docs.base44.com/developers/backend/resources/backend-functions/overview)
- [Integrations SDK reference (Base44 docs)](https://docs.base44.com/developers/references/sdk/docs/type-aliases/integrations)
- [Sending emails (Base44 docs)](https://docs.base44.com/documentation/building-your-app/sending-emails)