# `Tink.TransactionsContinuousAccess`
[🔗](https://github.com/iamkanishka/tink.ex/blob/v0.1.1/lib/tink/transactions_continuous_access.ex#L1)

Continuous access to account and transaction data with permanent users.

This module provides ongoing access to bank account and transaction data
through permanent user creation. Ideal for:

- Recurring data access
- Long-term financial monitoring
- Multi-session access
- Production applications

## Flow Overview

    # Step 1: Create permanent user
    client = Tink.client(scope: "user:create")

    {:ok, user} = Tink.TransactionsContinuousAccess.create_user(client, %{
      external_user_id: "user_123",
      market: "GB",
      locale: "en_US"
    })

    # Step 2: Grant user access for Tink Link
    grant_client = Tink.client(scope: "authorization:grant")

    {:ok, grant} = Tink.TransactionsContinuousAccess.grant_user_access(grant_client, %{
      user_id: user["user_id"],
      id_hint: "john.doe@example.com",
      scope: "authorization:read,authorization:grant,credentials:refresh,credentials:read,credentials:write,providers:read,user:read"
    })

    # Step 3: Build Tink Link URL
    tink_link_url = Tink.TransactionsContinuousAccess.build_tink_link(grant["code"], %{
      client_id: "your_client_id",
      market: "GB",
      locale: "en_US",
      redirect_uri: "https://yourapp.com/callback"
    })

    # Step 4: Redirect user to tink_link_url
    # User completes bank authentication
    # User is redirected back to your redirect_uri

    # Step 5: Create authorization for data access
    auth_client = Tink.client(scope: "authorization:grant")

    {:ok, auth} = Tink.TransactionsContinuousAccess.create_authorization(auth_client, %{
      user_id: user["user_id"],
      scope: "accounts:read,balances:read,transactions:read,provider-consents:read"
    })

    # Step 6: Get user access token
    {:ok, token} = Tink.TransactionsContinuousAccess.get_user_access_token(client, auth["code"])

    # Step 7: Create authenticated client
    user_client = Tink.client(access_token: token["access_token"])

    # Step 8: Access data anytime
    {:ok, accounts} = Tink.TransactionsContinuousAccess.list_accounts(user_client)
    {:ok, transactions} = Tink.TransactionsContinuousAccess.list_transactions(user_client)

## Complete Example

    defmodule MyApp.ContinuousTransactions do
      @spec setup_user(String.t(), String.t()) :: {:ok, map()} | {:error, term()}
      def setup_user(external_user_id, email) do
        # Step 1: Create user
        create_client = Tink.client(scope: "user:create")
        {:ok, user} = Tink.TransactionsContinuousAccess.create_user(create_client, %{
          external_user_id: external_user_id,
          market: "GB",
          locale: "en_US"
        })

        # Step 2: Grant access
        grant_client = Tink.client(scope: "authorization:grant")
        {:ok, grant} = Tink.TransactionsContinuousAccess.grant_user_access(grant_client, %{
          user_id: user["user_id"],
          id_hint: email,
          scope: "authorization:read,authorization:grant,credentials:refresh,credentials:read,credentials:write,providers:read,user:read"
        })

        # Step 3: Build Tink Link
        tink_link = Tink.TransactionsContinuousAccess.build_tink_link(grant["code"], %{
          client_id: Application.get_env(:my_app, :tink_client_id),
          market: "GB",
          locale: "en_US",
          redirect_uri: "https://myapp.com/callback"
        })

        {:ok, %{user_id: user["user_id"], tink_link: tink_link}}
      end

      @spec fetch_data(String.t()) :: {:ok, map()} | {:error, term()}

      def fetch_data(user_id) do
        # Create authorization
        auth_client = Tink.client(scope: "authorization:grant")
        {:ok, auth} = Tink.TransactionsContinuousAccess.create_authorization(auth_client, %{
          user_id: user_id,
          scope: "accounts:read,balances:read,transactions:read,provider-consents:read"
        })

        # Get token
        client = Tink.client()
        {:ok, token} = Tink.TransactionsContinuousAccess.get_user_access_token(client, auth["code"])

        # Fetch data
        user_client = Tink.client(access_token: token["access_token"])

        with {:ok, accounts} <- Tink.TransactionsContinuousAccess.list_accounts(user_client),
             {:ok, transactions} <- Tink.TransactionsContinuousAccess.list_transactions(user_client) do
          {:ok, %{accounts: accounts, transactions: transactions}}
        end
      end
    end

## Required Scopes

### User Creation
- `user:create`

### Authorization Grant
- `authorization:grant`
- `authorization:read`
- `credentials:refresh`
- `credentials:read`
- `credentials:write`
- `providers:read`
- `user:read`

### Data Access
- `accounts:read`
- `balances:read`
- `transactions:read`
- `provider-consents:read`

## Links

- [Continuous Access Documentation](https://docs.tink.com/resources/transactions/continuous-connect-to-a-bank-account)

# `build_tink_link`

```elixir
@spec build_tink_link(String.t(), map()) :: String.t()
```

Builds Tink Link URL for continuous access.

## Parameters

  * `authorization_code` - Code from grant_user_access
  * `opts` - Link options:
    * `:client_id` - Your client ID (required)
    * `:market` - Market code (required)
    * `:locale` - Locale code (required)
    * `:redirect_uri` - Callback URL (required)

## Returns

  * Tink Link URL string

## Examples

    tink_link = Tink.TransactionsContinuousAccess.build_tink_link(grant["code"], %{
      client_id: "your_client_id",
      market: "GB",
      locale: "en_US",
      redirect_uri: "https://yourapp.com/callback"
    })
    #=> "https://link.tink.com/1.0/transactions/connect-accounts?..."

# `create_authorization`

```elixir
@spec create_authorization(Tink.Client.t(), map()) ::
  {:ok, map()} | {:error, Tink.Error.t()}
```

Creates authorization for data access.

## Parameters

  * `client` - Tink client with `authorization:grant` scope
  * `params` - Authorization parameters:
    * `:user_id` - Tink user ID (required)
    * `:scope` - Data access scopes (required)

## Returns

  * `{:ok, authorization}` - Authorization with `code`
  * `{:error, error}` - If the request fails

## Examples

    auth_client = Tink.client(scope: "authorization:grant")

    {:ok, auth} = Tink.TransactionsContinuousAccess.create_authorization(auth_client, %{
      user_id: "tink_user_abc123",
      scope: "accounts:read,balances:read,transactions:read,provider-consents:read"
    })
    #=> {:ok, %{"code" => "data_auth_code"}}

## Required Scope

`authorization:grant`

# `create_user`

```elixir
@spec create_user(Tink.Client.t(), map()) :: {:ok, map()} | {:error, Tink.Error.t()}
```

Creates a permanent user for continuous access.

## Parameters

  * `client` - Tink client with `user:create` scope
  * `params` - User parameters:
    * `:external_user_id` - Your user identifier (required)
    * `:market` - Market code (e.g., "GB", "SE") (required)
    * `:locale` - Locale code (e.g., "en_US") (required)

## Returns

  * `{:ok, user}` - Created user with `user_id`
  * `{:error, error}` - If the request fails

## Examples

    client = Tink.client(scope: "user:create")

    {:ok, user} = Tink.TransactionsContinuousAccess.create_user(client, %{
      external_user_id: "user_123",
      market: "GB",
      locale: "en_US"
    })
    #=> {:ok, %{
    #     "user_id" => "tink_user_abc123",
    #     "external_user_id" => "user_123"
    #   }}

## Required Scope

`user:create`

# `get_user_access_token`

```elixir
@spec get_user_access_token(Tink.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Tink.Error.t()}
```

Gets user access token from authorization code.

## Parameters

  * `client` - Tink client
  * `code` - Authorization code from create_authorization

## Returns

  * `{:ok, token}` - Token response with access_token
  * `{:error, error}` - If the request fails

## Examples

    {:ok, token} = Tink.TransactionsContinuousAccess.get_user_access_token(client, auth["code"])
    #=> {:ok, %{
    #     "access_token" => "user_token_abc",
    #     "refresh_token" => "refresh_xyz",
    #     "expires_in" => 3600
    #   }}

# `grant_user_access`

```elixir
@spec grant_user_access(Tink.Client.t(), map()) ::
  {:ok, map()} | {:error, Tink.Error.t()}
```

Grants user access for Tink Link authentication.

## Parameters

  * `client` - Tink client with `authorization:grant` scope
  * `params` - Grant parameters:
    * `:user_id` - Tink user ID (required)
    * `:id_hint` - User identifier shown in Tink Link (required)
    * `:scope` - Scopes for Tink Link (required)

## Returns

  * `{:ok, grant}` - Authorization grant with `code`
  * `{:error, error}` - If the request fails

## Examples

    grant_client = Tink.client(scope: "authorization:grant")

    {:ok, grant} = Tink.TransactionsContinuousAccess.grant_user_access(grant_client, %{
      user_id: "tink_user_abc123",
      id_hint: "john.doe@example.com",
      scope: "authorization:read,authorization:grant,credentials:refresh,credentials:read,credentials:write,providers:read,user:read"
    })
    #=> {:ok, %{"code" => "auth_code_xyz"}}

## Required Scope

`authorization:grant`

# `list_accounts`

```elixir
@spec list_accounts(
  Tink.Client.t(),
  keyword()
) :: {:ok, map()} | {:error, Tink.Error.t()}
```

Lists all accounts for the continuous access user.

## Parameters

  * `client` - Tink client with user access token
  * `opts` - Query options (optional):
    * `:page_size` - Results per page (max 100)
    * `:page_token` - Next page token
    * `:type_in` - Filter by account types

## Returns

  * `{:ok, accounts}` - List of accounts
  * `{:error, error}` - If the request fails

## Examples

    user_client = Tink.client(access_token: user_access_token)

    {:ok, accounts} = Tink.TransactionsContinuousAccess.list_accounts(user_client)

## Required Scope

`accounts:read`

# `list_transactions`

```elixir
@spec list_transactions(
  Tink.Client.t(),
  keyword()
) :: {:ok, map()} | {:error, Tink.Error.t()}
```

Lists transactions for the continuous access user.

## Parameters

  * `client` - Tink client with user access token
  * `opts` - Query options (optional):
    * `:account_id_in` - Filter by account IDs
    * `:booked_date_gte` - Date >= filter
    * `:booked_date_lte` - Date <= filter
    * `:status_in` - Filter by status
    * `:page_size` - Results per page
    * `:page_token` - Next page token

## Returns

  * `{:ok, transactions}` - List of transactions
  * `{:error, error}` - If the request fails

## Examples

    user_client = Tink.client(access_token: user_access_token)

    {:ok, transactions} = Tink.TransactionsContinuousAccess.list_transactions(user_client,
      booked_date_gte: "2024-01-01",
      status_in: ["BOOKED"]
    )

## Required Scope

`transactions:read`

---

*Consult [api-reference.md](api-reference.md) for complete listing*