Add Ocrolus to your app 
========================

#### Use Ocrolus with Plaid Assets to digitize data collection 

(An image of "Logos of Plaid and Ocrolus side by side.")

  

Plaid and Ocrolus have partnered to offer lenders an easier way to access bank data to make informed loan decisions. Plaid enables businesses to instantly connect a customer's bank account, giving them the ability to authenticate and retrieve account details directly from the financial institution. Ocrolus digitizes bank and credit card statements from all US financial institutions to help lenders digitize their data collection for cash-flow analysis.

With the Plaid + Ocrolus integration, your users can verify their accounts in seconds by inputting their banking credentials in Plaid's front-end module. Plaid will retrieve the relevant bank information and pass it to Ocrolus for further digestion and reporting in a seamless, secure fashion. Plaid's mobile-friendly module handles input validation, error handling, and multi-factor authentication, providing a seamless onboarding experience to convert more users for your business.

#### Getting started 

You'll first want to familiarize yourself with [Plaid Link](https://plaid.com/docs/link/index.html.md) , a drop-in integration for the Plaid API that handles input validation, error handling, and multi-factor authentication. You will also need to create or be an existing [Ocrolus customer](https://www.ocrolus.com/get-api-keys/) in order to add a bank account.

Your customers will use Link to authenticate with their financial institution and select the bank account they wish to use for payment and verification of assets. From there, you'll receive a Plaid `access_token`, which you can use to generate an Ocrolus `processor_token` and/or `audit_copy_token`, depending on your use case, which allow you to quickly and securely verify banking information via the [Ocrolus API](https://www.ocrolus.com/) without having to store that sensitive information yourself.

#### Instructions 

##### Set up your Plaid and Ocrolus accounts 

You'll need accounts at both Plaid and Ocrolus in order to use the Plaid + Ocrolus integration. You'll also need to enable your Plaid account for the Ocrolus integration.

First, you will need to work with the Ocrolus team to [sign up for an Ocrolus account](https://www.ocrolus.com/get-api-keys/) , if you do not already have one.

Next, verify that your Plaid account is enabled for the integration. If you do not have a Plaid account, [create one](https://dashboard.plaid.com/signup/ocrolus) . Your account will be automatically enabled for integration access.

To verify that your Plaid account is enabled for the integration, go to the [Integrations](https://dashboard.plaid.com/developers/integrations) section of the account dashboard. If the integration is off, simply click the 'Enable' button for Ocrolus to enable the integration.

##### Create a link\_token 

In order to integrate with Plaid Link, you will first need to create a `link_token`. A `link_token` is a short-lived, one-time use token that is used to authenticate your app with Link. To create one, make a [/link/token/create](https://plaid.com/docs/api/link/index.html.md#linktokencreate) request with your `client_id`, `secret`, and a few other required parameters from your app server. View the [documentation](https://plaid.com/docs/api/link/index.html.md#linktokencreate) for a full list of `link_token` configurations.

To see your `client_id` and `secret`, visit the [Plaid Dashboard](https://dashboard.plaid.com/developers/keys) .

```node
app.post('/api/create_link_token', async function (request, response) {
  // Get the client_user_id by searching for the current user
  const user = await User.find(...);
  const clientUserId = user.id;
  const linkTokenRequest = {
    user: {
      // This should correspond to a unique id for the current user.
      client_user_id: clientUserId,
    },
    client_name: 'Plaid Test App',
    products: ['assets'],
    language: 'en',
    webhook: 'https://webhook.example.com',
    redirect_uri: 'https://domainname.com/oauth-page.html',
    country_codes: ['US'],
  };
  try {
    const createTokenResponse = await client.linkTokenCreate(linkTokenRequest);
    response.json(createTokenResponse.data);
  } catch (error) {
    // handle error
  }
});

```

```bash
curl -X POST https://sandbox.plaid.com/link/token/create \
-H 'Content-Type: application/json' \
-d '{
  "client_id": "${PLAID_CLIENT_ID}",
  "secret": "${PLAID_SECRET}",
  "client_name": "Plaid Test App",
  "user": { "client_user_id": "${UNIQUE_USER_ID}" },
  "products": ["assets"],
  "country_codes": ["US"],
  "language": "en",
  "webhook": "https://webhook.example.com",
  "redirect_uri": "https://domainname.com/oauth-page.html"
}'

```

```ruby
post '/api/create_link_token' do
  # Get the client_user_id by searching for the current user
  current_user = User.find(...)
  client_user_id = current_user.id

  # Create a link_token for the given user
  request = Plaid::LinkTokenCreateRequest.new(
    {
      user: { client_user_id: client_user_id },
      client_name: 'Plaid Test App',
      products: ['assets'],
      country_codes: ['US'],
      language: "en",
      redirect_uri: nil_if_empty_envvar('PLAID_REDIRECT_URI'),
      webhook: 'https://webhook.example.com'
    }
  )
  response = client.link_token_create(request)
  content_type :json
  response.to_json
end

```

```java
import com.plaid.client.model.Products;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.LinkTokenCreateRequest;
import com.plaid.client.model.LinkTokenCreateRequestUser;
import com.plaid.client.model.LinkTokenCreateResponse;

public class PlaidExample {

  ...
  static class GetLinkToken implements HttpHandler {
    private static PlaidApi plaidClient;

    public void handle(HttpExchange t) throws IOException {
      // Create your Plaid client
      HashMap apiKeys = new HashMap();
      apiKeys.put("clientId", CLIENT_ID);
      apiKeys.put("secret", SECRET);
      ApiClient apiClient = new ApiClient(apiKeys);
      apiClient.setPlaidAdapter(ApiClient.Sandbox);

      plaidClient = apiClient.createService(PlaidApi.class);

      // Get the clientUserId by searching for the current user
      User userFromDB = db.find(...);
      String clientUserId = userFromDB.id;
      LinkTokenCreateRequestUser user = new LinkTokenCreateRequestUser()
        .clientUserId(clientUserId);

      // Create a link_token for the given user
      LinkTokenCreateRequest request = new LinkTokenCreateRequest()
        .user(user)
        .clientName("Plaid Test App")
        .products(Arrays.asList(Products.fromValue("assets")))
        .countryCodes(Arrays.asList(CountryCode.US))
        .language("en")
        .redirectUri("https://domainname.com/oauth-page.html")
        .webhook("https://webhook.example.com");

      Response response = plaidClient
        .linkTokenCreate(request)
        .execute();

      // Send the data to the client
      return response.body();
    }
  }
}

```

```python
from plaid.model.link_token_create_request import LinkTokenCreateRequest
from plaid.model.link_token_create_request_user import LinkTokenCreateRequestUser
from plaid.model.products import Products
from plaid.model.country_code import CountryCode

@app.route("/create_link_token", methods=['POST'])
def create_link_token():
    # Get the client_user_id by searching for the current user
    user = User.find(...)
    client_user_id = user.id

    # Create a link_token for the given user
    request = LinkTokenCreateRequest(
            products=[Products("assets")],
            client_name="Plaid Test App",
            country_codes=[CountryCode('US')],
            redirect_uri='https://domainname.com/oauth-page.html',
            language='en',
            webhook='https://webhook.example.com',
            user=LinkTokenCreateRequestUser(
                client_user_id=client_user_id
            )
        )
    response = client.link_token_create(request)

    # Send the data to the client
    return jsonify(response.to_dict())


```

```go
func createLinkToken(c *gin.Context) {
  ctx := context.Background()

  // Get the client_user_id by searching for the current user
  user, _ := usermodels.Find(...)
  clientUserId := user.ID.String()

  // Create a link_token for the given user
  request := plaid.NewLinkTokenCreateRequest("Plaid Test App", "en", []plaid.CountryCode{plaid.COUNTRYCODE_US}, *plaid.NewLinkTokenCreateRequestUser(clientUserId))
  request.SetWebhook("https://webhook.sample.com")
  request.SetRedirectUri("https://domainname.com/oauth-page.html")
  request.SetProducts([]plaid.Products{plaid.PRODUCTS_ASSETS})

  resp, _, err := testClient.PlaidApi.LinkTokenCreate(ctx).LinkTokenCreateRequest(*request).Execute()

  // Send the data to the client
  c.JSON(http.StatusOK, gin.H{
    "link_token": resp.GetLinkToken(),
  })
}


```

##### Integrate with Plaid Link 

Once you have a `link_token`, all it takes is a few lines of client-side JavaScript to launch Link. Then, in the `onSuccess` callback, you can call a simple server-side handler to exchange the Link `public_token` for a Plaid `access_token` and an Ocrolus `processor_token`.

Integrate Link

```javascript
<button id="linkButton">Open Link - Institution Select</button>
<script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
<script>
  (async function(){
    var linkHandler = Plaid.create({
      // Make a request to your server to fetch a new link_token.
      token: (await $.post('/create_link_token')).link_token,
      onLoad: function() {
          // The Link module finished loading.
      },
      onSuccess: function(public_token, metadata) {
        // The onSuccess function is called when the user has
        // successfully authenticated and selected an account to
        // use.
        //
        // When called, you will send the public_token
        // and the selected accounts, metadata.accounts,
        // to your backend app server.
        //
        // sendDataToBackendServer({
        //   public_token: public_token,
        //   accounts: metadata.accounts
        // });
        console.log('Public Token: ' + public_token);
        console.log('Customer-selected account IDs: ' + metadata.accounts.map(account => account.id).join(', '));
      },
      onExit: function(err, metadata) {
        // The user exited the Link flow.
        if (err != null) {
            // The user encountered a Plaid API error
            // prior to exiting.
        }
        // metadata contains information about the institution
        // that the user selected and the most recent
        // API request IDs.
        // Storing this information can be helpful for support.
      },
    });
  })();

  // Trigger the authentication view
  document.getElementById('linkButton').onclick = function() {
    linkHandler.open();
  };
</script>
```

See the [Link parameter reference](https://plaid.com/docs/link/web/index.html.md#create) for complete documentation on possible configurations.

`Plaid.create` accepts one argument, a configuration `Object`, and returns an `Object` with three functions, [open](https://plaid.com/docs/link/web/index.html.md#open) , [exit](https://plaid.com/docs/link/web/index.html.md#exit) , and [destroy](https://plaid.com/docs/link/web/index.html.md#destroy) . Calling `open` will display the "Institution Select" view, calling `exit` will close Link, and calling `destroy` will clean up the iframe.

##### Write server-side handler 

The Link module handles the entire onboarding flow securely and quickly, but does not actually retrieve account data for a user. Instead, the Link module returns a `public_token` and an `accounts` array, which is a property on the `metadata` object, via the `onSuccess` callback. Exchange this `public_token` for a Plaid `access_token` using the [/item/public\_token/exchange](https://plaid.com/docs/api/items/index.html.md#itempublic_tokenexchange) API endpoint.

Once you have the `access_token` for the Item, you can create an Ocrolus `processor_token` and/or `audit_copy_token`. You'll send these tokens to Ocrolus and they will use them to securely retrieve banking information from Plaid.

```node
const {
  Configuration,
  PlaidApi,
  PlaidEnvironments,
  ProcessorTokenCreateRequest,
  AssetReportAuditCopyCreateRequest,
} = require('plaid');
// Change sandbox to production to test with live users or to go live!
const configuration = new Configuration({
  basePath: PlaidEnvironments[process.env.PLAID_ENV],
  baseOptions: {
    headers: {
      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
      'PLAID-SECRET': process.env.PLAID_SECRET,
      'Plaid-Version': '2020-09-14',
    },
  },
});

const plaidClient = new PlaidApi(configuration);

try {
  // Exchange the public_token from Plaid Link for an access token.
  const tokenResponse = await plaidClient.itemPublicTokenExchange({
    public_token: PUBLIC_TOKEN,
  });
  const accessToken = tokenResponse.data.access_token;

  // Create a processor token for a specific account id.
  const request: ProcessorTokenCreateRequest = {
    access_token: accessToken,
    account_id: accountID,
    processor: 'ocrolus',
  };
  const processorTokenResponse = await plaidClient.processorTokenCreate(
    request,
  );
  const processorToken = processorTokenResponse.data.processor_token;

  // Create an Asset Report for the specific access token.
  const request: AssetReportCreateRequest = {
    access_tokens: [accessToken],
    days_requested: 90,
    options: {},
  };
  const response = await plaidClient.assetReportCreate(request);
  const assetReportId = response.data.asset_report_id;
  const assetReportToken = response.data.asset_report_token;

  // Create an audit copy token for the Asset Report.
  const auditCopyRequest: AssetReportAuditCopyCreateRequest = {
    asset_report_token: response.data.asset_report_token,
    auditor_id: 'ocrolus',
  };
  const auditCopyResponse = await plaidClient.assetReportAuditCopyCreate(auditCopyRequest);
  const auditCopyToken = auditCopyResponse.data.audit_copy_token;
} catch (error) {
  // handle error
}

```

```bash
# Exchange the public token from Plaid Link for an access token.
curl \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "${PLAID_CLIENT_ID}",
    "secret": "${PLAID_SECRET}",
    "public_token": "${PUBLIC_TOKEN}"
  }' \
  -X POST \
  https://sandbox.plaid.com/item/public_token/exchange

# Create a processor token for a specific account id.
curl \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "${PLAID_CLIENT_ID}",
    "secret": "${PLAID_SECRET}",
    "access_token": "${ACCESS_TOKEN}",
    "account_id": "${ACCOUNT_ID}",
    "processor": "ocrolus"
  }' \
  -X POST \
  https://sandbox.plaid.com/processor/token/create

# Create an Asset Report for the specific access token.
curl \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "${PLAID_CLIENT_ID}",
    "secret": "${PLAID_SECRET}",
    "access_tokens": ["${ACCESS_TOKEN}"],
    "days_requested": 90
  }' \
  -X POST \
  https://sandbox.plaid.com/asset_report/create

# Create an audit copy token for the Asset Report.
curl \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "${PLAID_CLIENT_ID}",
    "secret": "${PLAID_SECRET}",
    "asset_report_token": "${ASSET_REPORT_TOKEN}",
    "auditor_id": "ocrolus"
  }' \
  -X POST \
  https://sandbox.plaid.com/asset_report/audit_copy/create

```

```ruby
require 'plaid'

# Change sandbox to production to test with live users or to go live!
configuration = Plaid::Configuration.new
configuration.server_index = Plaid::Configuration::Environment[ENV['PLAID_ENV'] || 'sandbox']
configuration.api_key['PLAID-CLIENT-ID'] = ENV['PLAID_CLIENT_ID']
configuration.api_key['PLAID-SECRET'] = ENV['PLAID_SECRET']
configuration.api_key['Plaid-Version'] = '2020-09-14'

api_client = Plaid::ApiClient.new(
  configuration
)

client = Plaid::PlaidApi.new(api_client)

# Exchange the public token from Plaid Link for an access token.
item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new(
  {
    public_token: public_token
  }
)
exchange_token_response = client.item_public_token_exchange(item_public_token_exchange_request)
access_token = exchange_token_response.access_token

# Create a processor token for a specific account id.
processor_token_create_request = Plaid::ProcessorTokenCreateRequest.new(
  {
    access_token: access_token,
    account_id: account_id,
    processor: "ocrolus"
  }
)
create_response = client.processor_token_create(processor_token_create_request)
processor_token = create_response.processor_token

# Create an Asset Report for the specific access token.
options = {
  client_report_id: '123',
  webhook: 'https://www.example.com',
  user: {
    client_user_id: '7f57eb3d2a9j6480121fx361',
    first_name: 'Jane',
    middle_name: 'Leah',
    last_name: 'Doe',
    ssn: '123-45-6789',
    phone_number: '(555) 123-4567',
    email: 'jane.doe@example.com',
  },
}
request = Plaid::AssetReportCreateRequest.new(
  {
    access_tokens: [access_token],
    days_requested: 90,
    options: options
  }
)
response = client.asset_report_create(request)
asset_report_id = response.asset_report_id
asset_report_token = response.asset_report_token

# Create an audit copy token for the Asset Report.
request = Plaid::AssetReportAuditCopyCreateRequest.new(
  {
    asset_report_token: asset_report_token,
    auditor_id: 'ocrolus'
  }
)
response = client.asset_report_audit_copy_create(request)
audit_copy_token = response.audit_copy_token

```

```java
import com.plaid.client.model.ItemPublicTokenExchangeRequest;
import com.plaid.client.model.ItemPublicTokenExchangeResponse;
import com.plaid.client.model.ProcessorTokenCreateRequest;
import com.plaid.client.model.ProcessorTokenCreateResponse;
import com.plaid.client.model.AssetReportCreateRequest;
import com.plaid.client.model.AssetReportUser;
import com.plaid.client.model.AssetReportCreateRequestOptions;
import com.plaid.client.model.AssetReportCreateResponse;
import com.plaid.client.model.AssetReportAuditCopyCreateRequest;
import com.plaid.client.model.AssetReportAuditCopyCreateResponse;

// Change sandbox to production to test with live users or to go live!
HashMap apiKeys = new HashMap();
apiKeys.put("clientId", plaidClientId);
apiKeys.put("secret", plaidSecret);
apiKeys.put("plaidVersion", "2020-09-14");
apiClient = new ApiClient(apiKeys);
apiClient.setPlaidAdapter(ApiClient.Sandbox);

plaidClient = apiClient.createService(PlaidApi.class);

// Exchange the public token from Plaid Link for an access token.
ItemPublicTokenExchangeRequest request = new ItemPublicTokenExchangeRequest()
  .publicToken(publicToken);

Response exchangeResponse = client()
  .itemPublicTokenExchange(request)
  .execute();

// Create a processor token for a specific account id.
if (exchangeResponse.isSuccessful()) {
  String accessToken = exchangeResponse.body().getAccessToken();
  ProcessorTokenCreateRequest request = new ProcessorTokenCreateRequest()
    .accessToken(accessToken)
    .processor("ocrolus")
    .accountId("FooBarAccountId");

  Response response = client()
    .processorTokenCreate(request)
    .execute();

    if (response.isSuccessful()) {
      String processorToken = response.body().getProcessorToken();
    }
}

// Create an Asset Report for the specific access token.
AssetReportCreateRequest assetReportCreateRequest = new AssetReportCreateRequest()
  .accessTokens(accessTokens)
  .daysRequested(90);

AssetReportUser assetReportUser = new AssetReportUser()
  .firstName("Alberta")
  .middleName("Bobbeth")
  .lastName("Charleson");

AssetReportCreateRequestOptions assetReportCreateOptions = new AssetReportCreateRequestOptions()
  .user(assetReportUser)
  .webhook(webhookUrl);

assetReportCreateRequest.options(assetReportCreateOptions);

Response response = client
  .assetReportCreate(assetReportCreateRequest)
  .execute();

String assetReportId = response.body().getAssetReportId();
String assetReportToken = response.body().getAssetReportToken();

// Create an audit copy token for the Asset Report.
AssetReportAuditCopyCreateRequest request = new AssetReportAuditCopyCreateRequest()
  .assetReportToken(assetReportToken)
  .auditorId("ocrolus");
Response response =
  client().assetReportAuditCopyCreate(request).execute();
String auditCopyToken = response.body().getAuditCopyToken();

```

```python
import plaid
from plaid.api import plaid_api
from plaid.model.item_public_token_exchange_request import ItemPublicTokenExchangeRequest
from plaid.model.processor_token_create_request import ProcessorTokenCreateRequest
from plaid.model.asset_report_create_request import AssetReportCreateRequest
from plaid.model.asset_report_audit_copy_create_request import AssetReportAuditCopyCreateRequest

# Change sandbox to production to test with live users or to go live!
configuration = plaid.Configuration(
    host=plaid.Environment.Sandbox,
    api_key={
        'clientId': PLAID_CLIENT_ID,
        'secret': PLAID_SECRET,
        'plaidVersion': '2020-09-14'
    }
)
api_client = plaid.ApiClient(configuration)
client = plaid_api.PlaidApi(api_client)

# Exchange the public token from Plaid Link for an access token.
exchange_request = ItemPublicTokenExchangeRequest(public_token=public_token)
exchange_token_response = client.item_public_token_exchange(exchange_request)
access_token = exchange_token_response['access_token']

# Create a processor token for a specific account id.
create_request = ProcessorTokenCreateRequest(
    access_token=access_token,
    account_id=account_id,
    processor="ocrolus"
)
create_response = client.processor_token_create(create_request)
processor_token = create_response['processor_token']

# Create an Asset Report for the specific access token.
request = AssetReportCreateRequest(
    access_tokens=[access_token],
    days_requested=90,
    options=AssetReportCreateRequestOptions(
        webhook='https://www.example.com',
        client_report_id='123',
        user=AssetReportUser(
            client_user_id='7f57eb3d2a9j6480121fx361',
            first_name='Jane',
            middle_name='Leah',
            last_name='Doe',
            ssn='123-45-6789',
            phone_number='(555) 123-4567',
            email='jane.doe@example.com',
        )
    )
)
response = client.asset_report_create(request)
asset_report_id = response['asset_report_id']
asset_report_token = response['asset_report_token']

# Create an audit copy token for the Asset Report.
request = AssetReportAuditCopyCreateRequest(
    asset_report_token=asset_report_token,
    auditor_id='ocrolus'
)
response = client.asset_report_audit_copy_create(request)
audit_copy_token = response['audit_copy_token']

```

```go
import (
  "context"
  "os"

  plaid "github.com/plaid/plaid-go/v42/plaid"
)

// create the client
configuration := plaid.NewConfiguration()
configuration.AddDefaultHeader("PLAID-CLIENT-ID", os.Getenv("CLIENT_ID"))
configuration.AddDefaultHeader("PLAID-SECRET", os.Getenv("SECRET"))
configuration.UseEnvironment(plaid.Sandbox)

// exchange the public_token for an access_token
exchangePublicTokenResp, _, err := client.PlaidApi.ItemPublicTokenExchange(ctx).ItemPublicTokenExchangeRequest(
  *plaid.NewItemPublicTokenExchangeRequest("PUBLIC_TOKEN"),
).Execute()
accessToken := exchangePublicTokenResp.GetAccessToken()

// get the account id
accountsResp, _, err := client.PlaidApi.AccountsGet(ctx).AccountsGetRequest(plaid.AccountsGetRequest{
  AccessToken: accessToken,
}).Execute()
accountID := accountsResp.GetAccounts()[0].GetAccountId()

// create a processor token for the specific account id
ocrolusTokenResp, _, err := client.PlaidApi.ProcessorTokenCreate(ctx).ProcessorTokenCreateRequest(
  *plaid.NewProcessorTokenCreateRequest(accessToken, accountID, "ocrolus"),
).Execute()

// create an asset report
assetReportCreateRequest := plaid.NewAssetReportCreateRequest(20)
assetReportCreateRequest.SetAccessTokens([]string{accessToken})
assetReportCreateResp, _, err := client.PlaidApi.AssetReportCreate(ctx).AssetReportCreateRequest(*assetReportCreateRequest).Execute()
assetReportToken := assetReportCreateResp.GetAssetReportToken()

// create an audit copy token for the Asset Report.
auditCopyCreateRequest := plaid.NewAssetReportAuditCopyCreateRequest(assetReportToken)
auditCopyCreateRequest.SetAuditorId(CLIENT_ID)
auditCopyCreateResponse, _, err := client.PlaidApi.AssetReportAuditCopyCreate(ctx).AssetReportAuditCopyCreateRequest(*auditCopyCreateRequest).Execute()
auditCopyToken := auditCopyCreateResponse.GetAuditCopyToken()

```

For a valid request, the API will return a JSON response similar to:

```json
{
  "processor_token": "processor-sandbox-0asd1-a92nc",
  "request_id": "UNIQUE_REQUEST_ID"
}
```

For a valid `audit_copy_token` request, the API will return a JSON response similar to:

```json
{
  "audit_copy_token": "a-sandbox-3TAU2CWVYBDVRHUCAAAI27ULU4",
  "request_id": "UNIQUE_REQUEST_ID"
}
```

For more information on creating Asset Report `audit_copy_tokens`, see the documentation for the [Assets](https://plaid.com/docs/assets/index.html.md) product.

##### Testing your Ocrolus integration 

You can create Ocrolus `processor_tokens` in Sandbox (sandbox.plaid.com, allows testing with simulated users). To test the integration in Sandbox mode, use the Plaid [Sandbox credentials](https://plaid.com/docs/sandbox/test-credentials/index.html.md) when launching Link with a `link_token` created in the Sandbox environment.

To move to Production, [request access](https://dashboard.plaid.com/settings/team/products) from the Dashboard. You will want to ensure that you have valid Ocrolus Production credentials prior to connecting bank accounts in the Ocrolus API with Plaid.

#### Support and questions 

Find answers to many common integration questions and concerns—such as pricing, sandbox and test mode usage, and more, in our [docs](https://plaid.com/docs/index.html.md) .

If you're still stuck, open a [support ticket](https://dashboard.plaid.com/support/new) with information describing the issue that you're experiencing and we'll get back to you as soon as we can.