> For a complete page index, fetch https://docs.transak.com/llms.txt

# Get FCA Requirements

GET https://api-gateway-stg.transak.com/api/v2/user/fca-requirements

The **Get FCA Requirements** is an **authenticated API call** that returns the FCA compliance requirements for a `UK` user based on their current FCA status. Use the `status` query parameter to fetch the relevant form data for categorization, investor agreement, risk assessment, cooling period, or blocked retry.

Reference: https://docs.transak.com/api/whitelabel/fca/get-fca-requirements

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: whitelabel-api
  version: 1.0.0
paths:
  /api/v2/user/fca-requirements:
    get:
      operationId: get-fca-requirements
      summary: Get FCA Requirements
      description: >-
        The **Get FCA Requirements** is an **authenticated API call** that
        returns the FCA compliance requirements for a `UK` user based on their
        current FCA status. Use the `status` query parameter to fetch the
        relevant form data for categorization, investor agreement, risk
        assessment, cooling period, or blocked retry.
      tags:
        - subpackage_fca
      parameters:
        - name: status
          in: query
          description: >-
            The current FCA status of the user. Call [Get FCA
            Status](/api/whitelabel/fca/get-fca-status) first to determine which
            step the user is on, then pass that value here to fetch the
            corresponding requirements.


            | Status | When to use |

            | --- | --- |

            | `CATEGORIZATION_PENDING` | Returns the investor categorization
            questionnaire |

            | `AGREEMENT_PENDING` | Returns the investor agreement content to
            display and accept |

            | `RISK_ASSESSMENT_PENDING` | Returns the risk assessment
            questionnaire |

            | `COOLING_PERIOD` | Returns the cooling-off period expiry timestamp
            |

            | `BLOCKED_RETRY` | Returns retry timing details after failed
            attempts |
          required: true
          schema:
            $ref: '#/components/schemas/FcaStatus'
        - name: authorization
          in: header
          description: >-
            Authorization token is the accessToken received from the API -`
            api/v2/auth/verify`


            Note: This is not applicable for [Auth Reliance
            Flows](/features/auth-reliance)
          required: false
          schema:
            type: string
        - name: x-user-identifier
          in: header
          description: >-
            Your authenticated user Email Id address.


            Note: This is applicable only for [Auth Reliance
            Flows](/features/auth-reliance)
          required: false
          schema:
            type: string
        - name: x-access-token
          in: header
          description: >
            Your Partner Access Token. Please refer
            [here](/guides/how-to-create-partner-access-token) for a tutorial on
            generating your access token.


            Note: This is applicable only for [Auth Reliance
            Flows](/features/auth-reliance)
          required: false
          schema:
            type: string
      responses:
        '200':
          description: 200 - Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FCA_get-fca-requirements_Response_200'
        '400':
          description: 400 - Bad Request
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Get-fca-requirementsRequestBadRequestError
        '401':
          description: 401 - Unauthorized
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Get-fca-requirementsRequestUnauthorizedError
        '404':
          description: 404 - User Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Get-fca-requirementsRequestNotFoundError'
        '500':
          description: 500 - Internal Server Error
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Get-fca-requirementsRequestInternalServerError
servers:
  - url: https://api-gateway-stg.transak.com
    description: Staging
components:
  schemas:
    FcaStatus:
      type: string
      enum:
        - CATEGORIZATION_PENDING
        - AGREEMENT_PENDING
        - RISK_ASSESSMENT_PENDING
        - RISK_ASSESSMENT_FAILED
        - COOLING_PERIOD
        - BLOCKED_RETRY
        - COMPLETED
      description: The current FCA compliance step for a UK user.
      title: FcaStatus
    FCA_get-fca-requirements_Response_200:
      type: object
      properties:
        data:
          type: object
          additionalProperties:
            description: Any type
      required:
        - data
      title: FCA_get-fca-requirements_Response_200
    ApiV2UserFcaRequirementsGetResponsesContentApplicationJsonSchemaError:
      type: object
      properties:
        statusCode:
          type: integer
        message:
          type: string
      required:
        - statusCode
        - message
      title: ApiV2UserFcaRequirementsGetResponsesContentApplicationJsonSchemaError
    Get-fca-requirementsRequestBadRequestError:
      type: object
      properties:
        error:
          $ref: >-
            #/components/schemas/ApiV2UserFcaRequirementsGetResponsesContentApplicationJsonSchemaError
      required:
        - error
      title: Get-fca-requirementsRequestBadRequestError
    Get-fca-requirementsRequestUnauthorizedError:
      type: object
      properties:
        error:
          $ref: >-
            #/components/schemas/ApiV2UserFcaRequirementsGetResponsesContentApplicationJsonSchemaError
      required:
        - error
      title: Get-fca-requirementsRequestUnauthorizedError
    Get-fca-requirementsRequestNotFoundError:
      type: object
      properties:
        error:
          $ref: >-
            #/components/schemas/ApiV2UserFcaRequirementsGetResponsesContentApplicationJsonSchemaError
      required:
        - error
      title: Get-fca-requirementsRequestNotFoundError
    Get-fca-requirementsRequestInternalServerError:
      type: object
      properties:
        error:
          $ref: >-
            #/components/schemas/ApiV2UserFcaRequirementsGetResponsesContentApplicationJsonSchemaError
      required:
        - error
      title: Get-fca-requirementsRequestInternalServerError

```

## Examples

### Categorization Pending



**Response**

```json
{
  "data": {
    "CATEGORIZATION_PENDING": {
      "assessmentSetId": "SET_A",
      "test": {
        "section1": [
          {
            "answers": [
              {
                "id": "A",
                "answer": "Yes"
              },
              {
                "id": "B",
                "answer": "No"
              }
            ],
            "questionId": "HNI_Q1",
            "questionNumber": 1,
            "question": "In the last financial year did you have an annual income of £100000 or more?",
            "description": "Income does not include any one off pension withdrawals.",
            "difficultyLevel": "Low",
            "questionCategory": "Categorization"
          },
          {
            "answers": [
              {
                "id": "A",
                "answer": "Yes"
              },
              {
                "id": "B",
                "answer": "No"
              }
            ],
            "questionId": "HNI_Q2",
            "questionNumber": 2,
            "question": "In the last financial year did you have net assets of £250000 or more?",
            "description": "Net assets do not include: your home (primary residence), your pension (or any pension withdrawals) or any rights under qualifying contracts of insurance.",
            "difficultyLevel": "Low",
            "questionCategory": "Categorization"
          }
        ]
      },
      "currentAttempt": "section1"
    }
  }
}
```

**SDK Code**

```python Categorization Pending
import requests

url = "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements"

querystring = {"status":"CATEGORIZATION_PENDING"}

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

print(response.json())
```

```javascript Categorization Pending
const url = 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING';
const options = {method: 'GET'};

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

```go Categorization Pending
package main

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

func main() {

	url := "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING"

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

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

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

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

}
```

```ruby Categorization Pending
require 'uri'
require 'net/http'

url = URI("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")

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

request = Net::HTTP::Get.new(url)

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

```java Categorization Pending
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")
  .asString();
```

```php Categorization Pending
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING');

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

```csharp Categorization Pending
using RestSharp;

var client = new RestClient("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift Categorization Pending
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
```

### Agreement Pending



**Response**

```json
{
  "data": {
    "AGREEMENT_PENDING": {
      "title": "Investor Agreement",
      "content": "I accept that being a HIGH_NET_WORTH_INVESTOR will expose me to promotions for investment where there is a risk of losing all the money I invest. I am aware that it is open to me to seek professional advice before making any investment in a high-risk investment.\n\nPutting all your money into a single business or type of investment is risky. Spreading your money across different investments makes you less dependent on any one to do well.\n\n• You should not invest more than 10% of your net assets in high-risk investments. Doing so could expose you to significant losses.\n\n• For the purposes of this statement, net assets do NOT include: your home (primary residence), your pension (or any pension withdrawals) or any rights under qualifying contracts of insurance.\n\n• For the purposes of this statement high-risk investments are: peer-to-peer (P2P) loans; investment based crowdfunding; crypto assets (such as bitcoin); and unlisted debt and equity (such as in companies not listed on an exchange like the London Stock Exchange)"
    }
  }
}
```

**SDK Code**

```python Agreement Pending
import requests

url = "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements"

querystring = {"status":"CATEGORIZATION_PENDING"}

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

print(response.json())
```

```javascript Agreement Pending
const url = 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING';
const options = {method: 'GET'};

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

```go Agreement Pending
package main

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

func main() {

	url := "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING"

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

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

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

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

}
```

```ruby Agreement Pending
require 'uri'
require 'net/http'

url = URI("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")

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

request = Net::HTTP::Get.new(url)

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

```java Agreement Pending
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")
  .asString();
```

```php Agreement Pending
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING');

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

```csharp Agreement Pending
using RestSharp;

var client = new RestClient("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift Agreement Pending
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
```

### Risk Assessment Pending



**Response**

```json
{
  "data": {
    "RISK_ASSESSMENT_PENDING": {
      "assessmentSetId": "SET_A",
      "test": {
        "section1": [
          {
            "answers": [
              {
                "id": "A",
                "answer": "Up to 10%."
              },
              {
                "id": "B",
                "answer": "Up to 30%."
              },
              {
                "id": "C",
                "answer": "Over 50%."
              }
            ],
            "answerId": "",
            "questionId": "SET_A_Q2",
            "question": "What percentage of assets should a typical investor allocate to high-risk investments?",
            "difficultyLevel": "Low",
            "questionCategory": "Diversification",
            "questionNumber": 1
          },
          {
            "answers": [
              {
                "id": "A",
                "answer": "You own the crypto assets and bear any investment risks after purchasing."
              },
              {
                "id": "B",
                "answer": "Transak guarantees the value of your crypto assets."
              },
              {
                "id": "C",
                "answer": "The government controls your crypto assets and is responsible for any investment losses."
              }
            ],
            "answerId": "",
            "questionId": "SET_A_Q9",
            "question": "When you purchase cryptocurrencies through Transak, who owns them, and what does that imply for you?",
            "difficultyLevel": "Medium",
            "questionCategory": "Rights & Obligations",
            "questionNumber": 2
          },
          {
            "answers": [
              {
                "id": "A",
                "answer": "It's very risky, more so than keeping your money in a bank savings account or investing in the stock market."
              },
              {
                "id": "B",
                "answer": "It's not risky at all, similar to keeping your money in a bank savings account."
              },
              {
                "id": "C",
                "answer": "It's somewhat risky, comparable to investing in stocks on a major stock exchange."
              }
            ],
            "answerId": "",
            "questionId": "SET_A_Q5",
            "question": "How risky is investing in cryptocurrencies?",
            "difficultyLevel": "Medium",
            "questionCategory": "Attitude to Risk",
            "questionNumber": 3
          },
          {
            "answers": [
              {
                "id": "A",
                "answer": "Yes, because the price of crypto assets is volatile."
              },
              {
                "id": "B",
                "answer": "No, cryptocurrency prices stay more or less the same over time."
              },
              {
                "id": "C",
                "answer": "Not sure."
              }
            ],
            "answerId": "",
            "questionId": "SET_A_Q1",
            "question": "Can the value of my cryptocurrency investments change a lot over time?",
            "difficultyLevel": "Low",
            "questionCategory": "Attitude to Risk",
            "questionNumber": 4
          },
          {
            "answers": [
              {
                "id": "A",
                "answer": "No, unlike a bank, the money is not protected."
              },
              {
                "id": "B",
                "answer": "Yes, my money is guaranteed."
              },
              {
                "id": "C",
                "answer": "No, but some of my money is guaranteed."
              }
            ],
            "answerId": "",
            "questionId": "SET_A_Q6",
            "question": "If you lose your money, will the Financial Ombudsman Service or Financial Services Compensation Scheme protect you against crypto losses?",
            "difficultyLevel": "Medium",
            "questionCategory": "No Protection from Loss",
            "questionNumber": 5
          }
        ]
      },
      "currentAttempt": "section1"
    }
  }
}
```

**SDK Code**

```python Risk Assessment Pending
import requests

url = "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements"

querystring = {"status":"CATEGORIZATION_PENDING"}

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

print(response.json())
```

```javascript Risk Assessment Pending
const url = 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING';
const options = {method: 'GET'};

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

```go Risk Assessment Pending
package main

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

func main() {

	url := "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING"

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

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

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

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

}
```

```ruby Risk Assessment Pending
require 'uri'
require 'net/http'

url = URI("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")

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

request = Net::HTTP::Get.new(url)

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

```java Risk Assessment Pending
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")
  .asString();
```

```php Risk Assessment Pending
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING');

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

```csharp Risk Assessment Pending
using RestSharp;

var client = new RestClient("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift Risk Assessment Pending
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
```

### Cooling Period



**Response**

```json
{
  "data": {
    "COOLING_PERIOD": {
      "expiresAt": 1762314481000
    }
  }
}
```

**SDK Code**

```python Cooling Period
import requests

url = "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements"

querystring = {"status":"CATEGORIZATION_PENDING"}

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

print(response.json())
```

```javascript Cooling Period
const url = 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING';
const options = {method: 'GET'};

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

```go Cooling Period
package main

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

func main() {

	url := "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING"

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

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

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

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

}
```

```ruby Cooling Period
require 'uri'
require 'net/http'

url = URI("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")

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

request = Net::HTTP::Get.new(url)

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

```java Cooling Period
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")
  .asString();
```

```php Cooling Period
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING');

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

```csharp Cooling Period
using RestSharp;

var client = new RestClient("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift Cooling Period
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
```

### Blocked Retry



**Response**

```json
{
  "data": {
    "BLOCKED_RETRY": {
      "canRetryAfter": 1730419200000,
      "reason": "Maximum retry attempts exceeded",
      "waitTimeHours": 24
    }
  }
}
```

**SDK Code**

```python Blocked Retry
import requests

url = "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements"

querystring = {"status":"CATEGORIZATION_PENDING"}

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

print(response.json())
```

```javascript Blocked Retry
const url = 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING';
const options = {method: 'GET'};

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

```go Blocked Retry
package main

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

func main() {

	url := "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING"

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

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

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

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

}
```

```ruby Blocked Retry
require 'uri'
require 'net/http'

url = URI("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")

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

request = Net::HTTP::Get.new(url)

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

```java Blocked Retry
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")
  .asString();
```

```php Blocked Retry
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING');

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

```csharp Blocked Retry
using RestSharp;

var client = new RestClient("https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift Blocked Retry
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-gateway-stg.transak.com/api/v2/user/fca-requirements?status=CATEGORIZATION_PENDING")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
```