> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.redpincompany.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.redpincompany.com/_mcp/server.

# List payment sessions

GET https://api.redpincompany.com/v1/customers/{customer_id}/sessions

Retrieve payment sessions for a given customer.

You can filter sessions using `session_id`, `client_reference_id`, or `client_customer_ref`.
If filters are omitted, the endpoint returns a paginated list of sessions for the customer.


Reference: https://docs.redpincompany.com/api-reference/customers/hosted-experience/sessions/list-payment-sessions

## Authentication

- `Authorization` header (bearer token, required) — OAuth 2.0 Bearer token authentication. This API uses OAuth 2.0 Client Credentials flow. Please refer to the [Authentication](/api-guide/getting-started/authentication#oauth-20-authentication) section for detailed information on how to obtain and use your OAuth credentials.

## Servers

- `https://api.redpincompany.com` (Production, default)
- `https://api.currenciesdirect.com` (Production CD)
- `https://sandbox.redpincompany.com` (Sandbox)
- `https://sandbox.currenciesdirect.com` (Sandbox CD)

## Request

### Path parameters

- `customer_id` (string, required) — Unique identifier for the customer whose sessions are being retrieved.

### Query parameters

- `client_reference_id` (string, optional) — Client-provided reference used to retrieve an existing session for idempotent behaviour. For hosted sessions, this value is unique per customer. Reference: [client_reference_id](/api-reference/customers/hosted-experience/sessions/create-payment-session#request.body.client_reference_id)
- `client_customer_ref` (string, optional) — Client-provided customer reference used at session creation. Reference: [client_customer_ref](/api-reference/customers/hosted-experience/sessions/create-payment-session#request.body.client_customer_ref)
- `session_id` (string, optional) — Unique session identifier used to retrieve a specific session. Reference: [session_id response field](/api-reference/customers/hosted-experience/sessions/create-payment-session#response.body.session_id)
- `page` (integer, optional) — Page number for paginated results. Default is 1.
- `limit` (integer, optional) — Number of sessions to return per page. Default is 20, max is 100.

## Response

### 200

Successful response with matching sessions or a paginated list

- `sessions` (list of SessionSummaryResponse, required) — Session records that belong to the requested `customer_id`. When specific search filters are provided, this list returns either an empty list or sessions list.
- `meta` (SessionListMeta, required) — Pagination information for the current query.

## Errors

### 401 Unauthorized Error

Unauthorized - missing or invalid authentication token

- `code` (string, required) — Application-specific error code.
- `description` (string, required) — Summary of the error.
- `type` (enum, required) — Category or type of the error. - `VALIDATION_ERROR`: Error due to invalid input data or format - `AUTHORIZATION_ERROR`: Error related to insufficient permissions - `SYSTEM_ERROR`: Internal system or server errors - `RESOURCE_ERROR`: Error related to resource availability - `BUSINESS_ERROR`: Error related to business logic violations - `DATA_ERROR`: Error related to data inconsistencies or duplication
  - Allowed values: `VALIDATION_ERROR`, `AUTHORIZATION_ERROR`, `SYSTEM_ERROR`, `RESOURCE_ERROR`, `BUSINESS_ERROR`, `DATA_ERROR`
- `field` (string, optional) — (Optional) The specific field or parameter related to the error.
- `details` (string, optional) — (Optional) Additional information that may help in debugging the error.

### 403 Forbidden Error

Forbidden - the caller cannot access sessions for this customer

- `code` (string, required) — Application-specific error code.
- `description` (string, required) — Summary of the error.
- `type` (enum, required) — Category or type of the error. - `VALIDATION_ERROR`: Error due to invalid input data or format - `AUTHORIZATION_ERROR`: Error related to insufficient permissions - `SYSTEM_ERROR`: Internal system or server errors - `RESOURCE_ERROR`: Error related to resource availability - `BUSINESS_ERROR`: Error related to business logic violations - `DATA_ERROR`: Error related to data inconsistencies or duplication
  - Allowed values: `VALIDATION_ERROR`, `AUTHORIZATION_ERROR`, `SYSTEM_ERROR`, `RESOURCE_ERROR`, `BUSINESS_ERROR`, `DATA_ERROR`
- `field` (string, optional) — (Optional) The specific field or parameter related to the error.
- `details` (string, optional) — (Optional) Additional information that may help in debugging the error.

### 500 Internal Server Error

Internal server error

- `code` (string, required) — Application-specific error code.
- `description` (string, required) — Summary of the error.
- `type` (enum, required) — Category or type of the error. - `VALIDATION_ERROR`: Error due to invalid input data or format - `AUTHORIZATION_ERROR`: Error related to insufficient permissions - `SYSTEM_ERROR`: Internal system or server errors - `RESOURCE_ERROR`: Error related to resource availability - `BUSINESS_ERROR`: Error related to business logic violations - `DATA_ERROR`: Error related to data inconsistencies or duplication
  - Allowed values: `VALIDATION_ERROR`, `AUTHORIZATION_ERROR`, `SYSTEM_ERROR`, `RESOURCE_ERROR`, `BUSINESS_ERROR`, `DATA_ERROR`
- `field` (string, optional) — (Optional) The specific field or parameter related to the error.
- `details` (string, optional) — (Optional) Additional information that may help in debugging the error.

## Types

### SessionSummaryResponse

- `session_id` (string, required) — Unique identifier for the hosted payment session. Use this value to correlate session retrieval responses with session creation and webhook events.
- `client_reference_id` (string, required) — Client-provided reference for this payment/session in your system. This is the primary key for idempotent lookups and reconciliation. For hosted sessions, uniqueness is enforced per customer.
- `client_customer_ref` (string, required) — Client-provided customer reference submitted at session creation. Useful for mapping Redpin session records to your internal customer or contract record.
- `customer_id` (string, required) — Redpin customer identifier that owns the session. Only sessions for this customer are returned by this endpoint.
- `created_at` (datetime, required) — Timestamp when the session was created (UTC, [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)).
- `session_expires_at` (datetime, required) — Timestamp when the hosted session expires (UTC, [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)). After this time, the session URL is no longer valid for payment completion.
- `latest_status` (enum, required) — Most recent known status associated with the session. Allowed values include session and payment lifecycle statuses returned by the platform.
  - Allowed values: `SESSION_CREATED`, `SESSION_INITIATED`, `AWAITING_FUNDS`, `USER_SETUP_TRANSFER`, `RECEIVED_FUNDS`, `FX_COMPLETED`, `PAYOUT_INITIATED`, `PAYOUT_CREDITED`, `CANCELLED`, `PROCESSING`, `BOUNCED_BACK`, `PAYMENT_COMPLETED`
- `has_payment` (boolean, required) — Indicates whether a payment has been created for this session. If `false`, `payment_id` is omitted.
- `items` (list of SessionItemSummary, required) — Line items captured on the hosted session request. This may be an empty array when no items were provided at session creation.
- `payment_method` (enum, optional) — Payment method the buyer selected for this session. Present once the session has reached `USER_SETUP_TRANSFER`. The field is omitted entirely rather than returned as `null`. - `PAY_BY_BANK`: Pay by Bank - `MANUAL_TRANSFER`: Manual Bank Transfer
  - Allowed values: `PAY_BY_BANK`, `MANUAL_TRANSFER`
- `payment_id` (string, optional) — Payment identifier assigned after payment creation. Present only when `has_payment` is `true`.

### SessionListMeta

- `page` (integer, required) — Current page number of the returned result set.
- `limit` (integer, required) — Maximum number of sessions requested per page.
- `total_records` (integer, required) — Total number of records matching the applied filters.
- `total_pages` (integer, required) — Total number of pages available for the applied filters and limit.

### SessionItemSummary

Summary representation of a session item.

- `item_name` (string, optional) — Human-readable display name for the item.
- `item_ref` (string, optional) — Optional client-side identifier for the item (for example invoice or property reference).
- `item_type` (string, optional) — Optional categorization for the item (for example `deposit`, `installment`, `service_charge`).
- `amount` (ItemAmount, optional) — Item amount in currency and value format.

### ItemAmount

- `currency` (string, required) — Three-letter ISO 4217 currency code. Must match the session total amount currency.
- `value` (double, required) — The amount for this specific item. **Validation Rules:** - Must be greater than 0 - Maximum precision: 2 decimal places - Currency must match session total amount currency

## Examples

### Customer-only listing

**Response**

```json
{
  "sessions": [
    {
      "session_id": "5a9b754c-6416-4254-b763-593182112d5b",
      "client_reference_id": "REF-CUST101-0001",
      "client_customer_ref": "CUST-101-ALPHA",
      "customer_id": "customer_101",
      "created_at": "2026-03-05T04:44:10.613934Z",
      "session_expires_at": "2026-03-10T04:44:10.612708Z",
      "latest_status": "SESSION_CREATED",
      "has_payment": false,
      "items": []
    },
    {
      "session_id": "9784e0bc-dec2-4311-9dd5-5f906d48541f",
      "client_reference_id": "REF-CUST101-0002",
      "client_customer_ref": "CUST-101-BETA",
      "customer_id": "customer_101",
      "created_at": "2026-02-12T10:48:56.522392Z",
      "session_expires_at": "2026-02-17T10:48:56.512765Z",
      "latest_status": "AWAITING_FUNDS",
      "has_payment": true,
      "items": [],
      "payment_id": "3937736"
    },
    {
      "session_id": "c4e1a8f2-6b30-4d91-9a77-2f8c1d0e55ab",
      "client_reference_id": "REF-CUST101-0003",
      "client_customer_ref": "CUST-101-GAMMA",
      "customer_id": "customer_101",
      "created_at": "2026-02-20T08:15:33.221004Z",
      "session_expires_at": "2026-02-25T08:15:33.220000Z",
      "latest_status": "USER_SETUP_TRANSFER",
      "has_payment": false,
      "items": [],
      "payment_method": "MANUAL_TRANSFER"
    }
  ],
  "meta": {
    "page": 1,
    "limit": 20,
    "total_records": 24,
    "total_pages": 2
  }
}
```

**SDK Code**

```python Customer-only listing
import requests

url = "https://api.redpincompany.com/v1/customers/customer_101/sessions"

querystring = {"page":"1","limit":"20"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Customer-only listing
const url = 'https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Customer-only listing
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Customer-only listing
require 'uri'
require 'net/http'

url = URI("https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Customer-only listing
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Customer-only listing
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Customer-only listing
using RestSharp;

var client = new RestClient("https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Customer-only listing
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.redpincompany.com/v1/customers/customer_101/sessions?page=1&limit=20")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Filter by client_reference_id

**Response**

```json
{
  "sessions": [
    {
      "session_id": "31f0d077-7ae7-478b-976b-0fc3421a02d1",
      "client_reference_id": "REF-CRID-2026-0001",
      "client_customer_ref": "CUST-202-OMEGA",
      "customer_id": "customer_202",
      "created_at": "2026-03-06T09:14:21.105230Z",
      "session_expires_at": "2026-03-11T09:14:21.105000Z",
      "latest_status": "PROCESSING",
      "has_payment": true,
      "items": [],
      "payment_method": "PAY_BY_BANK",
      "payment_id": "3938851"
    }
  ],
  "meta": {
    "page": 1,
    "limit": 20,
    "total_records": 1,
    "total_pages": 1
  }
}
```

**SDK Code**

```python Filter by client_reference_id
import requests

url = "https://api.redpincompany.com/v1/customers/customer_202/sessions"

querystring = {"client_reference_id":"REF-CRID-2026-0001"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Filter by client_reference_id
const url = 'https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Filter by client_reference_id
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Filter by client_reference_id
require 'uri'
require 'net/http'

url = URI("https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Filter by client_reference_id
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by client_reference_id
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Filter by client_reference_id
using RestSharp;

var client = new RestClient("https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by client_reference_id
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.redpincompany.com/v1/customers/customer_202/sessions?client_reference_id=REF-CRID-2026-0001")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Filter by client_customer_ref

**Response**

```json
{
  "sessions": [
    {
      "session_id": "71558d2d-c8f7-4f4d-8fb2-7f02e53d2316",
      "client_reference_id": "REF-CCREF-303-0001",
      "client_customer_ref": "CUST-303-REF",
      "customer_id": "customer_303",
      "created_at": "2026-03-04T10:05:44.208410Z",
      "session_expires_at": "2026-03-09T10:05:44.208000Z",
      "latest_status": "SESSION_CREATED",
      "has_payment": false,
      "items": []
    },
    {
      "session_id": "ae4c0057-640b-4d3e-a3c9-2335199377c4",
      "client_reference_id": "REF-CCREF-303-0002",
      "client_customer_ref": "CUST-303-REF",
      "customer_id": "customer_303",
      "created_at": "2026-03-03T06:58:19.546010Z",
      "session_expires_at": "2026-03-08T06:58:19.546000Z",
      "latest_status": "CANCELLED",
      "has_payment": false,
      "items": []
    }
  ],
  "meta": {
    "page": 1,
    "limit": 20,
    "total_records": 2,
    "total_pages": 1
  }
}
```

**SDK Code**

```python Filter by client_customer_ref
import requests

url = "https://api.redpincompany.com/v1/customers/customer_303/sessions"

querystring = {"client_customer_ref":"CUST-303-REF"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Filter by client_customer_ref
const url = 'https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Filter by client_customer_ref
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Filter by client_customer_ref
require 'uri'
require 'net/http'

url = URI("https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Filter by client_customer_ref
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by client_customer_ref
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Filter by client_customer_ref
using RestSharp;

var client = new RestClient("https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by client_customer_ref
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.redpincompany.com/v1/customers/customer_303/sessions?client_customer_ref=CUST-303-REF")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Filter by session_id

**Response**

```json
{
  "sessions": [
    {
      "session_id": "8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16",
      "client_reference_id": "REF-SID-404-0007",
      "client_customer_ref": "CUST-404-DELTA",
      "customer_id": "customer_404",
      "created_at": "2026-03-07T14:22:31.482900Z",
      "session_expires_at": "2026-03-12T14:22:31.482000Z",
      "latest_status": "AWAITING_FUNDS",
      "has_payment": true,
      "items": [],
      "payment_id": "3940022"
    }
  ],
  "meta": {
    "page": 1,
    "limit": 20,
    "total_records": 1,
    "total_pages": 1
  }
}
```

**SDK Code**

```python Filter by session_id
import requests

url = "https://api.redpincompany.com/v1/customers/customer_404/sessions"

querystring = {"session_id":"8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Filter by session_id
const url = 'https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Filter by session_id
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Filter by session_id
require 'uri'
require 'net/http'

url = URI("https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Filter by session_id
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by session_id
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Filter by session_id
using RestSharp;

var client = new RestClient("https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by session_id
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.redpincompany.com/v1/customers/customer_404/sessions?session_id=8d13f0db-6642-4ea6-9f7b-cdfe17f1ef16")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```