Use Signatoro in Base44 apps

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 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.
• 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.
2. 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:

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 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, Signatoro's MCP server and Resend, SendGrid, Postmark and SMTP.

Sources

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

• Setting up a custom MCP (Base44 docs)
• Using custom integrations (Base44 docs)
• Backend functions (Base44 docs)
• Integrations SDK reference (Base44 docs)
• Sending emails (Base44 docs)