Artegic Elaine

Artegic Elaine (also shown as “Elaine” in their own docs) is an email marketing and marketing-automation platform for real-time, personalised multichannel communication. Zeotap integrates with Elaine through two mutually-exclusive transports, selected when you create the destination:

• Recipient Group (SFTP) — the long-standing audience-sync mode. Zeotap uploads CSV files to Elaine’s ingest SFTP (sieis) folder; Elaine ingests them according to a filename convention and adds or removes members of a numeric recipient group.
• Trigger TAM Event (HTTPS) — trigger a pre-configured TAM (Trigger-Action-Mail) event in Elaine for every inbound row. This is an event-only flow; there is no audience concept beyond “one event per row”.
• Transactional API (HTTP/JSON) — dispatch personalised transactional messages through Elaine’s HTTP/JSON API. For every inbound row Zeotap either sends a specific transactional message (api_sendSingleTransaction) or fires a named event (api_processEvent) that routes to linked messages and subscribed automation campaigns. Transactional messages and recipient groups are selectable from searchable dropdowns populated from your Elaine account.

Prerequisites

• An Elaine account with a sieis SFTP user or a JWT bearer token for the TAM Event API (depending on which mode you pick).
• For SFTP mode: the numeric recipient group ID you want to sync into, and network reachability from Zeotap to your Elaine SFTP host (for example 7119.elaine-asp.de).
• For TAM mode: the domain URL of your Elaine instance (for example https://your-instance.elaine.io) and the event name that has already been configured inside Elaine.
• For Transactional API mode: the tenant-specific API base URL (for example https://abcd.elaine-asp.de) and either an API user + password (HTTP Basic) or a JWT bearer token. To send a specific message you also need the transactional message (nl_id); to fire an event you need the event name pre-configured in Elaine.

Authentication

Zeotap surfaces three auth methods (SFTP key-pair, Bearer JWT, and API User / HTTP Basic); pick the one that matches your integration mode.

SFTP — Public/Private Key

Elaine only supports RSA key-based authentication on the sieis account.

1. Generate an RSA key pair (or use an existing one). Give the public key to your Elaine administrator so they can register it against your sieis account.
2. In Zeotap, enter:
   • SFTP Username — the sieis user Elaine provided (for example 7119).
   • SFTP Private Key — the matching private key in OpenSSH or PEM format.
   • SFTP Public Key (optional, for reference) — the public key you sent to Elaine. Stored for your own records only.

Zeotap keeps the private key encrypted in its secret store and uses it only to connect to your Elaine SFTP host.

Bearer Token (JWT)

The TAM Event API — and, optionally, the Transactional API — uses a JSON Web Token (JWT) in the Authorization: Bearer header. Generate the token in your Elaine account and paste it into the Access Token field.

API User (HTTP Basic)

The Transactional HTTP/JSON API also accepts HTTP Basic authentication. Enter your Elaine API User and API Password; Zeotap sends them as an Authorization: Basic header on every call. Use this method or the JWT bearer token — whichever your Elaine account is configured for.

Configuration

Target Settings

Target settings apply only to SFTP mode; TAM events do not use a target object because every row fires its own event.

To find a Recipient Group ID, open your recipient group in the Elaine UI and read the integer ID shown in the group’s properties.

Supported Operations

Sync Modes

Elaine has no key-based upsert for either transport, so Zeotap only advertises insert-shaped sync modes.

Audience Sync Modes

Audience sync modes only apply to the SFTP transport.

If you pick the TAM Event or Transactional API integration mode, set the audience mode to Add; those modes are per-row sends (one API call per row) and do not honour remove/mirror.

Features

• Field Mapping: Yes
• Schema Introspection: No (custom fields are administered inside Elaine)

Required Mapping Fields

Default Destination Fields

c_email, c_prename (first name), c_name (last name), c_gender.

Elaine uses prefixes to tell fields apart:

• c_* — customer/recipient data fields
• e_* — event data fields
• t_* — transactional data fields

Create any custom fields you need inside Elaine first, then map your source columns to the matching c_ / e_ / t_ variable. Zeotap passes unknown columns through with their lower-cased names; Elaine silently drops variables it does not recognise.

How It Works

Recipient Group (SFTP)

1. Zeotap transforms your audience into rows keyed by Elaine variable names. email / raw_email / c_email are normalised to c_email; the configured default aliases map first_name → c_prename, last_name → c_name, gender → c_gender.
2. Rows are split according to the sync mode:
   • Add / Insert — everything goes to the add file.
   • Remove — everything goes to the remove file.
   • Mirror — the diff determines which file each row lands in.
3. Zeotap opens an SSH session to ${sftp_host}:${sftp_port} using your private key, opens the SFTP subsystem, and uploads the files under ${remote_directory} (default /sieis/import/upload/).
4. Filenames follow Elaine’s convention so the ingest daemon can parse the intent:
   • add_group=${groupId}_skip-unsubs=0_skip_deleted=${0|1}_${YYYYMMDD-HHmmss}.csv
   • remove_group=${groupId}_${YYYYMMDD-HHmmss}.csv
5. The CSV header row pins c_email to the first column; additional mapped columns follow in deterministic (sorted) order.

The SSH session is opened and torn down per batch so no idle sockets are held between syncs.

Trigger TAM Event (HTTPS)

1. For each row, Zeotap builds a payload of the form:

   {
     "recipientData": { "c_email": "johnsmith@example.com", ... }
   }

2. It POSTs that payload to ${domain_url}/elaine/api/tam/event/${event_name} with an Authorization: Bearer ${access_token} header.

3. Elaine returns a JSON body with success, message and a data array carrying the transactionId and messageId for each triggered message. Zeotap counts any row where success is true as succeeded and surfaces the API’s message (or the first per-row error) on failures.

Transactional API (HTTP/JSON)

All Transactional API calls use the same transport: a POST to {api_base_url}/http/api/{function} with a Content-Type: application/x-www-form-urlencoded body of json=<positional-args-array>&response=json, authenticated with HTTP Basic (API user) or a JWT bearer token.

Dynamic dropdowns. When you configure the destination, Zeotap calls api_getActionmails to populate the Transactional Message dropdown (filtered to transactional mails, falling back to api_getTemplates) and api_getGroupInfo to populate the Recipient Group dropdown (falling back to api_getGroups). Both are searchable and still allow typing an ID directly.

Message dispatch (api_sendSingleTransaction). For each row Zeotap builds a content object from the mapped c_/e_/t_ datafields (with c_email set from the recipient column) and sends the positional array [data, nl_id, ev_id, variant_position, blacklist]:

• data carries content, the configured priority, override, update_profile, and a msgid set to the row’s primary key.
• nl_id is the selected transactional message; ev_id is the optional recipient group (omitted when unset); variant_position selects a template variant (omitted when unset); blacklist reflects the Evaluate Blacklist toggle.
• The call returns an integer: a value > 0 is the mailing-queue id (success); a value < 0 is an ELAINE error code (see table below); false is an unknown error.

Event dispatch (api_processEvent). For each row Zeotap sends the positional array [event_name, recipientData, {}] where recipientData carries c_email plus the mapped datafields. Elaine routes the event to any transactional messages linked to it and to automation campaigns subscribed to it, auto-creating the recipient from c_email when needed. A negative integer or false return marks the row failed; anything else is treated as success.

ELAINE error codes

Negative return codes from api_sendSingleTransaction / api_processEvent are surfaced per row with the following names:

Rate Limits

Elaine does not publish formal rate limits. For the TAM Event API, Zeotap retries on 429 Too Many Requests and 5xx responses with exponential backoff. For the SFTP transport, Elaine ingests files asynchronously — uploads are lightweight and sync throughput is bounded by your network and SFTP concurrency rather than by an HTTP quota.

Best Practices

• Pick SFTP for bulk audience syncs — it’s Elaine’s preferred bulk channel, scales to several million recipients per file, and accepts .zip, .gz and .bz2 extensions if you ever need compression.
• Pick TAM for personalised event triggers — it is not a bulk loader; expect one API call per row.
• Keep c_email in every mapping — it is Elaine’s only supported primary identifier for recipient-group ingest.
• Set skip_deleted=0 only when you really want recycle-bin users re-subscribed — the default (1) matches Elaine’s safer behaviour.
• Create custom fields in Elaine first — Zeotap cannot introspect your Elaine schema, so any unknown c_* / e_* / t_* variables are silently dropped by Elaine’s ingest.

Troubleshooting

SSH authentication failed / permission denied

Check that the public key you gave to Elaine matches the private key stored in Zeotap and that it was registered against the same sieis user you entered as SFTP Username. Elaine’s sieis accounts only accept RSA key-based authentication — password auth is not supported.

Remote directory not reachable

The default remote directory is /sieis/import/upload/. If your Elaine admin has given you a different folder, override the Remote Directory field. Zeotap will try to mkdir -p the directory, but some sieis accounts are locked to the default.

Recipient group not updating after upload

Make sure the integer group ID you entered really exists in Elaine and that the uploaded filename shows the expected prefix (add_group=... or remove_group=...). Elaine ingests files asynchronously — allow a few minutes between the upload and the group update being visible in the UI.

Deleted recipients are not being re-subscribed

Check the Skip Deleted Recipients field. The default is 1, which tells Elaine to leave recycle-bin users alone. Set it to 0 if you want Elaine to re-subscribe deleted users on the next add import.

TAM event returns 401 / 403

The JWT bearer token is missing, expired or rotated. Regenerate the token inside Elaine and update the Access Token credential.

TAM event returns 404

Either the Domain URL is wrong, or the Event Name does not match a TAM event configured in Elaine. Event identifiers are case-sensitive and must match exactly what your Elaine admin configured.

Custom field not applied

Elaine ignores variables it does not recognise. Confirm the variable name inside Elaine (Data Fields → your field → variable value — usually prefixed with c_ or e_) and use that exact string as the destination field name in the Zeotap mapping.

Transactional API returns 401 / 403

The API credentials are wrong. For HTTP Basic, re-check the API User and API Password; for the JWT method, regenerate the Access Token in Elaine. The connection test lists your transactional messages, so a 401/403 there points at the credentials rather than the message configuration.

Transactional API dropdowns are empty

The Transactional Message and Recipient Group dropdowns are populated live from your Elaine account (api_getActionmails / api_getGroupInfo). An empty list usually means the account has no transactional mails / groups yet, or the API user lacks permission to list them. You can always type the numeric nl_id / ev_id directly.

Transactional message not sent (negative return)

api_sendSingleTransaction returns a negative ELAINE error code on failure — Zeotap surfaces the code and its name per row (see the error-code table above). Common causes: -14 USER_BLACKLISTED / -15 USER_BOUNCED (recipient suppressed — turn off Evaluate Blacklist only for true transactional mail), -12 INVALID_EMAIL (bad c_email), or -8 NOGROUP / -9 INVALIDGROUP (the configured recipient group does not exist).