> ## 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 Plaid 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 = ["Plaid Enrich API"];

<VendorApiVersionTag versions={vendorApiVersions} />

Complete the following prerequisites and configuration to start using the Plaid 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 deployed and configured [Sync Hub](/platform/sync-hub/overview) for your Grand Central runtime.
* You have an active Plaid Enrich contract and the credentials required for API authentication.
* You have network connectivity between Grand Central and Plaid. For supported options, see [Network connectivity](/platform/network-connectivity).

## Configuration

To configure the Plaid Connector, follow these steps:

1. When you call the unified API, set the `api-key` request header to `YOUR_SUBSCRIPTION_KEY`.

2. Obtain the Enrich API base URL, client ID, and secret for your Plaid sandbox or production environment. Grand Central sends the client ID and secret to Plaid as the `PLAID-CLIENT-ID` and `PLAID-SECRET` request headers. The connector maps the `PLAID_CLIENT_ID` and `PLAID_SECRET` environment variables to the `api.plaid.clientId` and `api.plaid.secret` properties.

3. Configure the Plaid Enrich URL and credentials in the `transaction-enrichment-v0.values.yaml` file in the `gc-applications-live` repository:

   ```properties theme={"system"}
   # Plaid Enrich API URL
   api.plaid.url=PLAID_ENRICH_URL
   # Plaid client ID (resolves from PLAID_CLIENT_ID)
   api.plaid.clientId=${PLAID_CLIENT_ID}
   # Plaid secret (resolves from PLAID_SECRET)
   api.plaid.secret=${PLAID_SECRET}
   ```

4. Confirm that the `transaction-enrichment-v0.values.yaml` file is in the following path. Replace `RUNTIME` with your runtime name, such as `dev` or `test`:

   ```text theme={"system"}
   ├── iPaaS
   └── azure/runtimes
       └── RUNTIME
           └── values
               └── gc-plaid
                   └── transaction-enrichment-v0.values.yaml
   ```

5. Configure the following Sync Hub Azure Service Bus (ASB) producer properties in `transaction-enrichment-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-plaid-transaction-enrichment-connector
   asb.event.topic=transactions-enriched
   asb.producer.apiUri=http://asb-producer-v0.synchub-producer.svc.cluster.local
   ```

6. Store the client ID and secret as the `PLAID_CLIENT_ID` and `PLAID_SECRET` environment variables in a SOPS secret. For more information, see [How to create SOPS](/platform/developer-guides/build/configure-connector).

## Set up the sandbox

Use the Plaid Enrich sandbox to explore enrichment requests before you integrate through Grand Central.

1. Obtain sandbox credentials and the Postman collection your Grand Central program team provides.
2. Import the Postman collection and environment into Postman.
3. Run sample enrichment requests against the Plaid sandbox to confirm credentials, request shape, and response fields.
4. Compare Plaid field names with the Grand Central mapping in the [Plaid field mapping sheet](https://docs.google.com/spreadsheets/d/1nfj_V-AEArcRhvS60wu8zGU2yIpxwjaO_4EYfNagtEo/edit?gid=759261116#gid=759261116).

For sandbox coordination and environment updates, contact your Grand Central program team.

## Test your integration

1. Call `POST {baseURL}/internal/transactions/enrichment` with a test batch that includes a UUID `enrichmentRequestId`, a `partyInformation` array, and at least one account with at least one transaction.
2. Confirm Grand Central returns `202` with an empty body.
3. Confirm the connector publishes `transactionsEnriched` to Sync Hub after the synchronous Plaid Enrich call completes.
4. Verify downstream consumers receive the expected enrichment payload, including category, merchant, and location fields.

For operation and event details, see [Reference](/connectors/financial-data-aggregation/plaid-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:** Plaid client credentials are missing or incorrect.

    **Solution:** Verify credentials with Plaid, then update `PLAID_CLIENT_ID` and `PLAID_SECRET` in the SOPS secret with the Grand Central team.
  </Accordion>

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

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

  <Accordion icon="bell" title="No enrichment result event received">
    **Cause:** Azure Service Bus (ASB) producer properties point to the wrong topic, or the connector failed before publishing to Sync Hub.

    **Solution:** Verify ASB producer configuration on the connector deployment. Check connector logs for mapping or vendor errors after the Plaid Enrich call.
  </Accordion>
</AccordionGroup>