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

# List jurisdictions visible to your organisation

GET https://staging.cail.health/v1/jurisdictions

Returns a cursor-paginated list of jurisdictions the operator’s organisation has visibility into. Today the list resolves to the operator’s home jurisdiction (the one they are scoped to via FHIR organization metadata). Use for context when authoring jurisdiction-specific content or running cross-jurisdiction reporting.

Reference: https://docs.cail.health/api-references/api-reference/understand-coverage/list

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: cail-api
  version: 1.0.0
paths:
  /v1/jurisdictions:
    get:
      operationId: list
      summary: List jurisdictions visible to your organisation
      description: >-
        Returns a cursor-paginated list of jurisdictions the operator’s
        organisation has visibility into. Today the list resolves to the
        operator’s home jurisdiction (the one they are scoped to via FHIR
        organization metadata). Use for context when authoring
        jurisdiction-specific content or running cross-jurisdiction reporting.
      tags:
        - subpackage_understandCoverage
      parameters:
        - name: cursor
          in: query
          description: Opaque cursor returned from a prior call. Omit on the first page.
          required: false
          schema:
            type: string
        - name: limit
          in: query
          description: Maximum number of results to return. Defaults to 20.
          required: false
          schema:
            type: number
            format: double
        - name: Authorization
          in: header
          description: Bearer authentication
          required: true
          schema:
            type: string
      responses:
        '200':
          description: A cursor-paginated page of jurisdictions.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ListJurisdictionsResponse'
servers:
  - url: https://staging.cail.health
    description: https://staging.cail.health
components:
  schemas:
    JurisdictionListItemCode:
      type: object
      properties: {}
      description: Jurisdiction code, mirrors the FHIR identifier.
      title: JurisdictionListItemCode
    JurisdictionListItem:
      type: object
      properties:
        id:
          type: string
          description: Stable identifier of the jurisdiction.
        code:
          oneOf:
            - $ref: '#/components/schemas/JurisdictionListItemCode'
            - type: 'null'
          description: Jurisdiction code, mirrors the FHIR identifier.
        name:
          type: string
          description: Display name in the request locale.
        country:
          type: string
          description: ISO country code.
        subdivisionCode:
          type: string
          description: ISO 3166-2 subdivision code.
        locale:
          type: string
          description: Default locale.
        timezone:
          type: string
          description: Default timezone.
        emergencyNumber:
          type: string
          description: Emergency phone number.
        nonEmergencyNumber:
          type: string
          description: Non-emergency phone number.
        currency:
          type: string
          description: ISO 4217 currency code.
      required:
        - id
        - code
        - name
      title: JurisdictionListItem
    ListJurisdictionsPaginationCursor:
      type: object
      properties: {}
      description: Opaque cursor for the next page. Null when there are no more results.
      title: ListJurisdictionsPaginationCursor
    ListJurisdictionsPagination:
      type: object
      properties:
        cursor:
          oneOf:
            - $ref: '#/components/schemas/ListJurisdictionsPaginationCursor'
            - type: 'null'
          description: >-
            Opaque cursor for the next page. Null when there are no more
            results.
        hasMore:
          type: boolean
          description: True when more results exist after this page.
        limit:
          type: number
          format: double
          description: Echoes the requested page size for client convenience.
      required:
        - cursor
        - hasMore
        - limit
      title: ListJurisdictionsPagination
    ListJurisdictionsResponse:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: '#/components/schemas/JurisdictionListItem'
          description: Jurisdiction rows for this page.
        pagination:
          $ref: '#/components/schemas/ListJurisdictionsPagination'
          description: Cursor metadata for paging forward.
      required:
        - data
        - pagination
      title: ListJurisdictionsResponse
  securitySchemes:
    auth0Bearer:
      type: http
      scheme: bearer

```

## Examples



**Response**

```json
{
  "data": [
    {
      "id": "jur_uk_eng",
      "code": "uk-eng",
      "name": "NHS England",
      "country": "GB",
      "subdivisionCode": "GB-ENG",
      "locale": "en-GB",
      "timezone": "Europe/London",
      "emergencyNumber": "999",
      "nonEmergencyNumber": "111",
      "currency": "GBP"
    }
  ],
  "pagination": {
    "cursor": null,
    "hasMore": false,
    "limit": 20
  }
}
```

**SDK Code**

```python An operator scoped to NHS England
import requests

url = "https://staging.cail.health/v1/jurisdictions"

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

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

print(response.json())
```

```javascript An operator scoped to NHS England
const url = 'https://staging.cail.health/v1/jurisdictions';
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 An operator scoped to NHS England
package main

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

func main() {

	url := "https://staging.cail.health/v1/jurisdictions"

	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 An operator scoped to NHS England
require 'uri'
require 'net/http'

url = URI("https://staging.cail.health/v1/jurisdictions")

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 An operator scoped to NHS England
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://staging.cail.health/v1/jurisdictions")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php An operator scoped to NHS England
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://staging.cail.health/v1/jurisdictions', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp An operator scoped to NHS England
using RestSharp;

var client = new RestClient("https://staging.cail.health/v1/jurisdictions");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift An operator scoped to NHS England
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://staging.cail.health/v1/jurisdictions")! 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()
```