> ## 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.

# Get started

> Configure and deploy the SaltEdge Connector with Grand Central

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} />

Complete the following prerequisites and configuration to start using the SaltEdge Connector.

## Prerequisites

Before you begin, make sure you meet the following requirements:

* You have completed the steps in [Get started with connectors](/connectors/getting-started).
* You have an active SaltEdge Data Enrichment contract and the credentials required for API and webhook authentication.
* You have network connectivity between Grand Central and SaltEdge. For supported options, see [Network connectivity](/platform/network-connectivity).

## Configuration

To configure the SaltEdge Connector, follow these steps:

1. Set your API Management (APIM) subscription key in the header as follows:
   * Key: `api-key`
   * Value: `YOUR_SUBSCRIPTION_KEY`

2. Obtain the application credentials for your SaltEdge environment. SaltEdge issues an `App-Id` and an `App-Secret`. Grand Central sends both values to SaltEdge as request headers. Store them in a SOPS secret:
   * `saltedge-position-keeping-app-id`
   * `saltedge-position-keeping-secret`

3. Configure the SaltEdge base URL and customer ID in the `gc-applications-live` repository in the connector's `values.yaml` file:

   ```properties theme={"system"}
   # SaltEdge environment base URL
   saltedge.baseUrl=SALTEDGE_BASE_URL
   # SaltEdge customer ID
   saltedge.customer-id=SALTEDGE_CUSTOMER_ID
   ```

4. Verify the `values.yaml` file locations in the repository. Both files are in the `gc-saltedge` folder. Replace `RUNTIME` with your runtime name, such as `dev` or `test`:

   ```text theme={"system"}
   ├── iPaaS
   └── azure/runtimes
       └── RUNTIME
           └── values
               └── gc-saltedge
                   ├── position-keeping-v0.values.yaml
                   └── position-keeping-inbound-v0.values.yaml
   ```

5. Expose the SaltEdge categorization webhook at `POST {baseInboundURL}/webhooks/transaction-categorizations`. Register this URL with SaltEdge.

6. Add the following signature-verification properties to `position-keeping-inbound-v0.values.yaml`:

   ```properties theme={"system"}
   # Flag to enable signature verification
   saltedge.callback.signature.enabled=SIGNATURE_VERIFICATION_FLAG
   # Callback URL to receive the payload
   saltedge.callback.url=CALLBACK_URL
   # Signature public key from the SaltEdge documentation
   saltedge.callback.signature.public-key.v6_0=PUBLIC_KEY
   ```

7. Configure the following Sync Hub Azure Service Bus (ASB) producer properties in `position-keeping-inbound-v0.values.yaml` so the `transactionsEnriched` event reaches the correct topic and schema version:

   ```properties theme={"system"}
   asb.event.version=1.1.0
   asb.event.type=transactionsEnriched
   asb.event.source=gc-saltedge-position-keeping-inbound-connector
   asb.event.topic=transactions-enriched
   asb.producer.apiUri=http://asb-producer-v0.synchub-producer.svc.cluster.local
   ```

8. Store SaltEdge credentials and webhook secrets in a SOPS secret. For more information, see [How to create SOPS](/platform/developer-guides/build/configure-connector).

## Test your integration

1. Call `POST {baseURL}/internal/transactions/enrichment` with a test batch. The batch must include a unique `enrichmentRequestId`, a `partyInformation` array, and at least one entry in `accounts`.
2. Confirm Grand Central returns `202` with an empty body.
3. When SaltEdge sends the categorization callback to `POST {baseInboundURL}/webhooks/transaction-categorizations`, confirm the connector publishes `transactionsEnriched` to Sync Hub.
4. Verify downstream consumers receive the expected enrichment payload.

For operation and event details, see [Reference](/connectors/financial-data-aggregation/saltedge-transaction-enrichment/reference). For the full contract, see [API playground](/connectors/reference/unified-api-playground).

## Troubleshooting

If the connector does not respond as expected, check these common scenarios.

<AccordionGroup>
  <Accordion icon="key" title="Authentication failure">
    **Cause:** SaltEdge application credentials or webhook signing details are missing or incorrect.

    **Solution:** Verify credentials with SaltEdge, then update the SOPS secret with the Grand Central team.
  </Accordion>

  <Accordion icon="wifi-slash" title="Timeout or connectivity error">
    **Cause:** Grand Central cannot reach the SaltEdge Data Enrichment endpoint within the configured timeout.

    **Solution:** Confirm network routing and the operational status of the SaltEdge environment. If both look healthy, contact [GC Support](mailto:gc_support@backbase.com).
  </Accordion>

  <Accordion icon="bell" title="No enrichment result event received">
    **Cause:** The SaltEdge webhook callback did not reach Grand Central, or ASB producer properties point to the wrong topic.

    **Solution:** Confirm the callback URL registered with SaltEdge matches `POST {baseInboundURL}/webhooks/transaction-categorizations`. Verify ASB producer configuration on the connector deployment.
  </Accordion>
</AccordionGroup>