Switching to Quiltt gives you access to multiple data providers through a single integration, enriched financial data, and powerful payment operations. Whether or not you're currently using an aggregator like Plaid, MX, or Finicity, Quiltt provides a smooth migration path.

You can migrate in two ways: import all existing connections at once for a complete switchover, or gradually roll out Quiltt alongside your existing provider using feature detection.

Link to this section#Choosing the Right Approach

Link to this section#Prerequisites

Before migrating, ensure:

1. Provider integration enabled - Configure your provider (e.g., Plaid) in Quiltt Dashboard with your credentials in Test environment first
2. SDK installed - React, React Native, etc.
3. Authentication configured - Issue session tokens from your backend and wrap your app with QuilttProvider

Link to this section#Option 1: Import Existing Connections

For a complete switchover, import your existing provider connections to Quiltt and swap your connector implementation.

Link to this section#When to Use Imports

• Migrating your entire user base at once
• Replacing an existing provider integration completely
• Need to maintain existing connection history
• Want a clean cutover with minimal code changes

Link to this section#Benefits of Importing

• One-time migration process
• Full feature access to Quiltt's enrichment and payment operations
• Centralized connection management
• Simplified codebase with single integration

Link to this section#How Importing Works

1. Import Connections via API: Use Quiltt's REST API to import existing provider connections (e.g., Plaid access tokens)
2. Swap Connector: Replace your existing connector UI with Quiltt Connector
3. Continue Operations: All existing connections work seamlessly in Quiltt

Link to this section#Import Implementation Steps

1. Import Connections

Use the Quiltt REST API to import your existing Plaid Items:

POSThttps://api.quiltt.io/v1/profiles/{profileId}/connections/import/plaidCopy endpoint URL to clipboard

curl -X POST https://api.quiltt.io/v1/profiles/{PROFILE_ID}/connections/import/plaid \
  -H "Authorization: Bearer YOUR_API_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "accessToken": "access-sandbox-..."
  }'

Required parameters

• accessToken: The access token associated with the Plaid Item you want to import.

Optional parameters

For a full list of optional parameters (e.g., mode, products, createdAt), see the REST API Reference. The options below are generally not recommended, but are available for advanced use cases:

• externallyManaged: Set to true if you don't want Quiltt to remove the Plaid Item from upstream when it is disconnected. Your existing system will need to manage upstream cleanup to avoid charges after disconnecting from Quiltt. Defaults to false.
• migrateWebhook: Set to false to keep Plaid webhooks pointing to your existing system instead of Quiltt. Defaults to true.

Build a migration script to import all existing connections:

import { getPlaidTokensFromDatabase } from './database'

async function migrateUserConnections(profileId: string, plaidAccessTokens: string[]) {
  for (const accessToken of plaidAccessTokens) {
    const response = await fetch(
      `https://api.quiltt.io/v1/profiles/${profileId}/connections/import/plaid`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.QUILTT_API_SECRET}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          accessToken
        })
      }
    )

    if (!response.ok) {
      throw new Error(`Failed to import: ${response.statusText}`)
    }

    const connection = await response.json()
    console.log(`Imported connection: ${connection.id}`)
  }
}

async function runMigration() {
  const users = await getPlaidTokensFromDatabase()

  for (const user of users) {
    try {
      await migrateUserConnections(user.profileId, user.plaidAccessTokens)
      console.log(`✓ Migrated user ${user.id}`)
    } catch (error) {
      console.error(`✗ Failed to migrate user ${user.id}:`, error)
    }
  }
}

2. Update Your Frontend

Replace your existing connector with Quiltt Connector:

import { usePlaidLink } from 'react-plaid-link'

function ConnectButton() {
  const { open } = usePlaidLink({
    token: plaidLinkToken,
    onSuccess: (public_token) => {
      // Exchange and store token
    }
  })

  return <button className="my-fancy-button" onClick={open}>Connect Bank</button>
}

import { QuilttButton } from '@quiltt/react'

function ConnectButton() {
  return (
    <QuilttButton
      connectorId="<CONNECTOR_ID>"
      onExitSuccess={(metadata) => {
        console.log('Connected:', metadata.connectionId)
      }}
      className="my-fancy-button"
    >
      Connect Bank
    </QuilttButton>
  )
}

3. Verify Migration

• Test that imported connections appear in Quiltt Dashboard
• Check that Webhooks are being received
• Verify data sync is working correctly by querying the API

Link to this section#Option 2: Gradual Migration with Resolvable Check

For a phased rollout, use the useQuilttResolvable hook to selectively migrate users while maintaining backward compatibility.

Link to this section#When to Use Resolvable Check

• Testing Quiltt with a subset of users
• Running both providers in parallel
• Gradual rollout to minimize risk
• Need to maintain existing provider code during transition
• Migrating institution by institution

Link to this section#Benefits of Resolvable Check

• Low-risk incremental rollout
• A/B testing capabilities
• Maintain existing provider as fallback
• Easier rollback if issues arise
• Validate institution by institution

Link to this section#How Resolvable Check Works

1. Check Institution Compatibility: Use useQuilttResolvable to check if a provider's institution is supported by Quiltt
2. Conditional Rendering: Show Quiltt Connector for supported institutions, fallback to existing provider for others
3. Gradual Expansion: As you verify success, expand to more institutions

Link to this section#Resolvable Check Implementation

import { useQuilttResolvable, QuilttButton } from '@quiltt/react'
import { useEffect } from 'react'
import { usePlaidLink } from 'react-plaid-link'

function SmartConnectButton({ plaidInstitutionId, institutionName }) {
  const { checkResolvable, isResolvable, isLoading } = useQuilttResolvable('<CONNECTOR_ID>')

  useEffect(() => {
    checkResolvable({ plaid: plaidInstitutionId })
  }, [plaidInstitutionId])

  const { open: openPlaidLink } = usePlaidLink({
    token: plaidLinkToken,
    onSuccess: handlePlaidSuccess
  })

  if (isLoading) return <div>Loading...</div>

  if (isResolvable) {
    return (
      <QuilttButton
        connectorId="<CONNECTOR_ID>"
        institution={institutionName}
        onExitSuccess={(metadata) => {
          console.log('Connected via Quiltt:', metadata.connectionId)
        }}
      >
        Connect Bank
      </QuilttButton>
    )
  }

  return <button onClick={openPlaidLink}>Connect Bank</button>
}

// Usage
<SmartConnectButton plaidInstitutionId="ins_3" institutionName="Chase" />

import { useQuilttResolvable } from '@quiltt/react-native'
import { useEffect } from 'react'
import { Text, TouchableOpacity } from 'react-native'

function SmartConnectButton({ plaidInstitutionId, institutionName, navigation }) {
  const { checkResolvable, isResolvable, isLoading } = useQuilttResolvable('<CONNECTOR_ID>')

  useEffect(() => {
    checkResolvable({ plaid: plaidInstitutionId })
  }, [plaidInstitutionId])

  if (isLoading) return <Text>Loading...</Text>

  if (isResolvable) {
    return (
      <TouchableOpacity
        onPress={() => navigation.navigate('QuilttConnector', { institutionName })}
      >
        <Text>Connect Bank</Text>
      </TouchableOpacity>
    )
  }

  return (
    <TouchableOpacity onPress={() => {/* Your Plaid Link implementation */}}>
      <Text>Connect Bank</Text>
    </TouchableOpacity>
  )
}

// In your QuilttConnector screen:
export const QuilttConnectorScreen = ({ route, navigation }) => {
  const { institutionName } = route.params || {}

  return (
    <QuilttConnector
      connectorId="<CONNECTOR_ID>"
      institution={institutionName}
      appLauncherUrl="<YOUR_HTTPS_APP_LINK>"
      onExitSuccess={(metadata) => {
        console.log('Connected via Quiltt:', metadata.connectionId)
        navigation.navigate('Home')
      }}
      onExitAbort={() => navigation.navigate('Home')}
    />
  )
}

Link to this section#Related Resources

• Core Concepts - Understand Profiles, Connections, and Integrations
• Connector Overview - Learn about Quiltt Connector features and configuration
• Authentication Guide - Set up Session tokens for secure API access
• Webhooks - Monitor connection status and data sync events
• Reconnect Flow - Handle connection errors and re-authentication
• Account Aggregation Integrations - Plaid, MX, Finicity, and Akoya documentation
• REST API Reference - Complete REST API documentation