> ## Documentation Index
> Fetch the complete documentation index at: https://agenticbanking.backbase.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> Enrich transaction narratives with category, merchant, and location insights using the SaltEdge Connector

export const VendorApiVersionTag = ({versions, label = "Supports"}) => {
  useEffect(() => {
    if (!versions || versions.length === 0) {
      return undefined;
    }
    const findAndSegmentStart = (reference, target) => {
      let i = 0;
      while (i < reference.length && i < target.length && reference[i] === target[i]) {
        i += 1;
      }
      let start = i;
      while (start > 0 && (/[0-9.vR]/).test(target[start - 1])) {
        start -= 1;
      }
      return start;
    };
    const formatText = () => {
      const suffix = " operations";
      if (versions.length === 1) {
        return `${label} ${versions[0]}${suffix}`;
      }
      const [first, ...rest] = versions;
      const last = rest[rest.length - 1];
      const andStart = findAndSegmentStart(first, last);
      const lead = first.slice(0, andStart);
      if (versions.length === 2) {
        return `${label} ${first} and ${last.slice(andStart)}${suffix}`;
      }
      const stems = versions.map(version => version.slice(andStart));
      return `${label} ${lead}${stems.slice(0, -1).join(", ")}, and ${stems[stems.length - 1]}${suffix}`;
    };
    const text = formatText();
    const mountCallout = () => {
      const title = document.querySelector("#page-title");
      const header = title?.closest("header") ?? document.querySelector("#header");
      if (!title || !header || !header.contains(title)) {
        return null;
      }
      let titleBlock = title;
      while (titleBlock.parentElement && titleBlock.parentElement !== header) {
        titleBlock = titleBlock.parentElement;
      }
      let callout = header.querySelector("[data-vendor-api-version-callout='true']");
      if (!callout) {
        callout = document.createElement("div");
        callout.dataset.vendorApiVersionCallout = "true";
        callout.className = "vendor-api-version-callout";
        titleBlock.insertAdjacentElement("afterend", callout);
      }
      callout.replaceChildren();
      const textEl = document.createElement("span");
      textEl.className = "vendor-api-version-text";
      textEl.textContent = text;
      callout.appendChild(textEl);
      return callout;
    };
    let callout = mountCallout();
    if (callout) {
      return () => {
        callout?.remove();
      };
    }
    const observer = new MutationObserver(() => {
      callout = mountCallout();
      if (callout) {
        observer.disconnect();
      }
    });
    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
    return () => {
      observer.disconnect();
      callout?.remove();
    };
  }, [versions, label]);
  return null;
};

export const vendorApiVersions = ["SaltEdge Data Enrichment API v6"];

<VendorApiVersionTag versions={vendorApiVersions} />

The SaltEdge Connector integrates Grand Central with [SaltEdge Data Enrichment](https://www.saltedge.com/products/data_enrichment) to enrich raw account transactions with vendor-native categories, merchant details, counterparties, and location. The connector delivers results to downstream consumers through Sync Hub.

SaltEdge enrichment is asynchronous. After Grand Central accepts a batch, the connector calls the SaltEdge categorization APIs. The connector publishes the final event only after it receives the SaltEdge webhook callback. This differs from the Grand Central [Open Banking connectors](/connectors/open-banking/overview), which use SaltEdge for PSD2 consent and account-information services in the UK and EU.

## Key capabilities

<CardGroup cols={2}>
  <Card title="Multi-step categorization" icon="gears">
    Orchestrate SaltEdge categorization buckets, accounts, transactions, and start flows.
  </Card>

  <Card title="Merchant resolution" icon="store">
    When SaltEdge returns a `merchant_id`, the connector calls the SaltEdge merchants API to retrieve names, contact information, and address data. The connector adds the merchant details to the enrichment event.
  </Card>

  <Card title="Webhook-driven completion" icon="webhook">
    Receive SaltEdge categorization completion callbacks on a Grand Central webhook endpoint. The connector verifies the SaltEdge signature on every callback.
  </Card>

  <Card title="Unified async delivery" icon="tower-broadcast">
    Transform SaltEdge-native responses into the Grand Central enrichment event model and publish to Sync Hub for the Engagement Banking Platform and other subscribers.
  </Card>
</CardGroup>

## Supported operations

The SaltEdge Connector supports the following operations from the Grand Central transaction enrichment unified API.

### Outbound

| Operation                           | Endpoint                                          |
| :---------------------------------- | :------------------------------------------------ |
| Accept transaction enrichment batch | `POST {baseURL}/internal/transactions/enrichment` |

### Inbound (webhook)

| Operation                                | Endpoint                                                     |
| :--------------------------------------- | :----------------------------------------------------------- |
| Receive SaltEdge categorization callback | `POST {baseInboundURL}/webhooks/transaction-categorizations` |

Replace `{baseURL}` with the transaction enrichment API base URL and `{baseInboundURL}` with the transaction enrichment inbound API base URL from your setup. Register the webhook URL in your SaltEdge configuration to receive categorization completion callbacks.

Grand Central returns `202` with an empty body. The response does not contain enriched transaction data.

<Note>
  An enrichment request can contain a maximum of 50 accounts. Each account can contain a maximum of 100 transactions. For the full validation rules, see [Reference](/connectors/financial-data-aggregation/saltedge-transaction-enrichment/reference).
</Note>

### Enrichment events (Sync Hub)

When SaltEdge categorization completes, the connector publishes unified enrichment events to Sync Hub. Downstream consumers subscribe to Sync Hub to receive updates. You do not need to poll SaltEdge directly.

| Event                  | When emitted                                                                         |
| :--------------------- | :----------------------------------------------------------------------------------- |
| `transactionsEnriched` | SaltEdge categorization completes successfully (including partial per-item outcomes) |

Published events use the standard Grand Central envelope. The `data` payload includes per-transaction category, merchant, location, and counterparties.

The connector publishes an event only when the SaltEdge callback reports a completed categorization. For any other callback status, the connector acknowledges the callback and publishes no event.

For how Sync Hub distributes events to multiple consumers, see [Sync Hub overview](/platform/sync-hub/overview).

### Core use cases supported

<CardGroup cols={2}>
  <Card title="Spending insights and PFM" icon="chart-pie">
    Group transactions by category and merchant, improve search using enriched narratives, and feed category-level aggregates into budget and goal features in digital banking apps.
  </Card>

  <Card title="Agent-assisted servicing" icon="headset">
    Give agents enriched merchant and location context when customers dispute or query transactions.
  </Card>
</CardGroup>

## Related topics

* [Reference](/connectors/financial-data-aggregation/saltedge-transaction-enrichment/reference) for the Grand Central Unified API endpoints that support these features.
* [Get started](/connectors/financial-data-aggregation/saltedge-transaction-enrichment/get-started) for deployment steps.