Marketo Engage (Transactional Email API)

Send The Wallet Crew transactional emails via Marketo Engage using the script email provider.

Use this option when the organization uses Marketo Engage and wants transactional sends tracked in Marketo activity logs.

Before going further, make sure the script provider model used by The Wallet Crew is clear. Start with Adobe Marketing Cloud and the prerequisite EmailSender extensibility.

When to use this

This is often the simplest REST model, but it assumes the email template is managed and approved in Marketo.

Setup required in Marketo

Create the email asset to send and get it approved. Approval rules vary by Marketo setup.

Then decide how The Wallet Crew output is mapped:

• Use Marketo tokens or variables to inject Subject and Body.

• Or keep the subject and body in Marketo and only pass contextual data.

Implementation notes (token + send)

Marketo instances are region-specific. The script usually requests a Marketo access token, then calls the transactional send endpoint for the chosen email asset.

Store these values as secrets before testing:

• marketo-baseUrl (example: https://123-ABC-456.mktorest.com)

• marketo-clientId

• marketo-clientSecret

• marketo-emailId (the Marketo email asset identifier to send)

Marketo OAuth token endpoints can differ slightly by instance and configuration. When the Marketo token endpoint requires query parameters or a specific HTTP method, adapt the authentication settings accordingly.

Marketo Engage example (SendEmail implementation)

import { getSecret } from "neo/secrets";

const CUSTOM_DOMAIN = "wallet.brand.com";
const TENANTID = "brand";

async function sendEmail(recipient, emailTemplate, data, cultures, buildEmail) {
  const email = recipient;
  const countryCode = data["country"] || "fr";
  const language = `${cultures[0]?.toLowerCase()?.substring(0, 2) || "fr"}_${countryCode.toLowerCase()}`;
  const customerId = data["id.customerId"];

  if (!customerId) {
    throw new Error('Missing "id.customerId" in email data.');
  }

  const url = `https://${CUSTOM_DOMAIN}/${TENANTID}/pass?id.customerId=${encodeURIComponent(customerId)}`;
  const rendered = await buildEmail(emailTemplate);

  const baseUrl = await getSecret("marketo-baseUrl");
  const clientId = await getSecret("marketo-clientId");
  const clientSecret = await getSecret("marketo-clientSecret");
  const marketoEmailId = await getSecret("marketo-emailId");

  const sendUrl = `${baseUrl}/rest/v1/email/${encodeURIComponent(marketoEmailId)}/send.json`;

  // Your runtime `fetch` handles OAuth client credentials and attaches the token.
  const result = await fetch(sendUrl, {
    Method: "POST",
    Authentication: {
      mode: "OAuth2.0",
      grantType: "clientCredentials",
      sendCredentialsAsFormParams: true,
      accessTokenUrl: `${baseUrl}/identity/oauth/token`,
      clientId,
      clientSecret,
    },
    Headers: {
      "Content-Type": "application/json",
    },
    Body: JSON.stringify({
      input: [
        {
          email,
          variables: [
            { name: "url", value: url },
            { name: "language", value: language },
            { name: "subject", value: rendered.Subject },
            { name: "body", value: rendered.Body },
            { name: "customerId", value: customerId },
            { name: "template", value: emailTemplate },
          ],
        },
      ],
    }),
    ThrowOnError: false,
  });

  if (result.StatusCode < 200 || result.StatusCode >= 300) {
    throw new Error(`Marketo send call failed (${result.StatusCode}): ${result.ResponseText}`);
  }
}

export default function (context) {
  context.register("runtime.scriptable.emailEngine", {
    SendEmail: sendEmail,
  });
}

Marketo requires the email asset to exist (and often to be approved) before it can be used for sends.

What to validate

Trigger a real transactional email, then validate these points:

• The email asset exists and is approved.

• Marketo accepts the send call.

• Variables map to what the Marketo template expects.

FAQ

Does the email template have to be created in Marketo?

Yes. Marketo requires an existing email asset for transactional sends, and many setups require the asset to be approved. The script can still pass variables, but Marketo needs the container asset.

Can The Wallet Crew still render the HTML?

Yes. buildEmail() can be called and subject and body passed as variables. The Marketo email must be built to inject those variables into the right places.

What is the quickest way to troubleshoot?

First check that the asset is approved, then check the Marketo API response body for a specific error code. If the API call succeeds but the email renders badly, validate that the Marketo template expects the same variable names that are sent.

Can different Marketo instances be used per environment?

Yes. Configure different secrets and endpoints per tenant (staging vs production). Keep variable naming consistent across environments to avoid template drift.