> 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

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: management-api
  version: 1.0.0
paths:
  /GetAvailableRegulations:
    post:
      operationId: get-available-regulations
      summary: GetAvailableRegulations
      description: |-
        Searches for the available regulation for a link.

        Allowed roles: `Owner`, `Accountant`.

        **Example request:** Search available regulation address.
      tags:
        - subpackage_regulationAddress
      parameters:
        - name: country_code
          in: query
          description: The country code according to the **ISO 3166-1 alpha-2**
          required: true
          schema:
            type: string
        - name: phone_category_name
          in: query
          description: The phone category name. See the [GetPhoneNumberCategories] method
          required: true
          schema:
            type: string
        - name: phone_region_code
          in: query
          description: The phone region code. See the [GetRegions] method
          required: false
          schema:
            type: string
        - name: Authorization
          in: header
          description: >-
            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.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/regulation-address_GetAvailableRegulations_Response_200
servers:
  - url: https://api.voximplant.com/platform_api
components:
  schemas:
    GetAvailableRegulationsPostResponsesContentApplicationJsonSchemaResult:
      oneOf:
        - type: boolean
        - type: integer
      description: >-
        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
      title: GetAvailableRegulationsPostResponsesContentApplicationJsonSchemaResult
    RegulationAddress:
      type: object
      properties:
        regulation_address_id:
          type: integer
          description: The regulation address ID
        external_id:
          type: string
          description: The external ID
        country_code:
          type: string
          description: The country code
        phone_category_name:
          type: string
          description: The phone category name
        salutation:
          type: string
          description: 'The salutation. Possible values: MR, MS, COMPANY'
        company:
          type: string
          description: The company name
        first_name:
          type: string
          description: The first name
        last_name:
          type: string
          description: The last name
        owner_country_code:
          type: string
          description: The owner country code
        city:
          type: string
          description: The city name
        zip_code:
          type: string
          description: The zip code
        street:
          type: string
          description: The zip code
        builder_number:
          type: string
          description: The builder number
        builder_latter:
          type: string
          description: The builder latter
        status:
          type: string
          description: >-
            The status verification. Possible values: IN_PROGRESS, VERIFIED,
            DECLINED
        reject_message:
          type: string
          description: The reject message
        id:
          type: integer
      description: The [GetRegulationsAddress] and [GetAvailableRegulations] result.
      title: RegulationAddress
    regulation-address_GetAvailableRegulations_Response_200:
      type: object
      properties:
        result:
          $ref: >-
            #/components/schemas/GetAvailableRegulationsPostResponsesContentApplicationJsonSchemaResult
          description: >-
            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:
          type: array
          items:
            $ref: '#/components/schemas/RegulationAddress'
          description: The available RegulationAddress records
        count_in_progress:
          type: integer
          description: The count of RegulationAddress in progress status
      title: regulation-address_GetAvailableRegulations_Response_200
  securitySchemes:
    JwtAuth:
      type: http
      scheme: bearer
      description: >-
        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.

```

## SDK Code Examples

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