> For a complete documentation index, fetch https://docs.voximplant.ai/llms.txt

# GetAvailableRegulations

POST https://api.voximplant.com/platform_api/GetAvailableRegulations

Searches for the available regulation for a link.

Allowed roles: `Owner`, `Accountant`.

**Example request:** Search available regulation address.

Reference: https://docs.voximplant.ai/api-reference/management-api/reference/regulation-address/get-available-regulations

## Authentication

- `Authorization` header (bearer token, required) — Voximplant Management API uses signed JWT tokens generated from your service-account private key. Pass the token in the `Authorization` header as a Bearer value: ``` Authorization: Bearer $VOXIMPLANT_TOKEN ``` See [Authorization](/api-reference/management-api/authorization) for ready-to-copy snippets in bash, Python, Node.js and Go that turn your `credentials.json` into a token.

## Request

### Query parameters

- `country_code` (string, required) — The country code according to the **ISO 3166-1 alpha-2**
- `phone_category_name` (string, required) — The phone category name. See the [GetPhoneNumberCategories] method
- `phone_region_code` (string, optional) — The phone region code. See the [GetRegions] method

## Response

### 200

Successful response

- `result` (GetAvailableRegulationsPostResponsesContentApplicationJsonSchemaResult, optional) — Whether the user has at least one regulation address which is appropriate for verification or the verification is not required. If result is false, the regulations address needs to be created
- `available_address` (list of RegulationAddress, optional) — The available RegulationAddress records
- `count_in_progress` (integer, optional) — The count of RegulationAddress in progress status

## Types

### GetAvailableRegulationsPostResponsesContentApplicationJsonSchemaResult

Whether the user has at least one regulation address which is appropriate for verification or the verification is not required. If result is false, the regulations address needs to be created

### RegulationAddress

The [GetRegulationsAddress] and [GetAvailableRegulations] result.

- `regulation_address_id` (integer, optional) — The regulation address ID
- `external_id` (string, optional) — The external ID
- `country_code` (string, optional) — The country code
- `phone_category_name` (string, optional) — The phone category name
- `salutation` (string, optional) — The salutation. Possible values: MR, MS, COMPANY
- `company` (string, optional) — The company name
- `first_name` (string, optional) — The first name
- `last_name` (string, optional) — The last name
- `owner_country_code` (string, optional) — The owner country code
- `city` (string, optional) — The city name
- `zip_code` (string, optional) — The zip code
- `street` (string, optional) — The zip code
- `builder_number` (string, optional) — The builder number
- `builder_latter` (string, optional) — The builder latter
- `status` (string, optional) — The status verification. Possible values: IN_PROGRESS, VERIFIED, DECLINED
- `reject_message` (string, optional) — The reject message
- `id` (integer, optional)

## Examples

**Response**

```json
{
  "result": 1,
  "available_address": [
    {
      "external_id": "12345",
      "country_code": "DE",
      "phone_category_name": "GEOGRAPHIC",
      "salutation": "MR",
      "first_name": "First",
      "last_name": "last",
      "city": "City",
      "zip_code": "140000",
      "street": "street",
      "builder_number": "10",
      "status": "VERIFIED",
      "id": 1
    }
  ],
  "count_in_progress": 0
}
```

**SDK Code**

```python Example 1
import requests

url = "https://api.voximplant.com/platform_api/GetAvailableRegulations"

querystring = {"country_code":"country_code","phone_category_name":"phone_category_name"}

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

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

print(response.json())
```

```javascript Example 1
const url = 'https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name';
const options = {method: 'POST', 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 Example 1
package main

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

func main() {

	url := "https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name"

	req, _ := http.NewRequest("POST", 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 Example 1
require 'uri'
require 'net/http'

url = URI("https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name")

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

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

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

```java Example 1
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Example 1
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Example 1
using RestSharp;

var client = new RestClient("https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Example 1
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.voximplant.com/platform_api/GetAvailableRegulations?country_code=country_code&phone_category_name=phone_category_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```