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

# Servicing Provider Eligibility

GET https://api.rebateright.com.au/Providers/{providerNumber}/ServicingEligibility/{itemNumber}

Checks whether a **servicing (rendering) provider** may perform and claim a given MBS item. It runs *before* the claim is lodged, so a wrong-provider rejection is caught up front rather than at assessment.

The check runs entirely within RebateRight: no Medicare call and no patient details, only a `providerNumber` and an `itemNumber`. That makes it fast enough to validate every line of a batch and safe to run with no patient data in play.

<CardGroup cols={1}>
<Card title="Provider Atlas: every specialty and credential" icon="sitemap" href="/provider-atlas">
Every eligibility answer rests on the recognition Medicare holds for the provider. The Provider Atlas maps them all, and shows how the same recognitions decide who may render, claim, and refer each item.
</Card>
</CardGroup>

#### The sources behind every check

RebateRight resolves the answer from the authoritative sources that govern who may render an item:

<CardGroup cols={2}>
<Card title="Provider recognitions">The specialties, fields and credentials Medicare recognises for the provider, expanded through RebateRight's recognition hierarchy so that allowing a broad class (such as a specialist medical practitioner) automatically covers every sub-specialty beneath it.</Card>
<Card title="MBS item structure">The item's MBS category, group and sub-group (the layered structure mapped to eligible specialties), together with the item's own descriptor, which can override the group rule where an individual item is tighter or broader.</Card>
<Card title="Legislative determinations">The Diagnostic Imaging, Pathology and General Medical Services Tables on the Federal Register: the legislation that sets, item by item, which providers may render and bill a service, beyond what the descriptor alone states.</Card>
<Card title="MBS explanatory notes">Conditions a specialty alone cannot express, such as Approved Pathology Practitioner status, nuclear-medicine credentialling, or CT coronary angiography recognition. RebateRight surfaces these in the Reason as a "verify separately" pointer with its MBS reference.</Card>
</CardGroup>

To stay accurate, RebateRight continually reconciles its determinations against Medicare. The result is advisory: the binding decision is made when the claim is assessed.

#### Reading the result

A `200` always returns a boolean `IsEligible` and a plain-language `Reason`. Three shapes come back:

- **`IsEligible: true` with a specialty named.** One of the provider's specialties may render the item; the `Reason` names the matching specialty and the MBS group or item rule it satisfied.
- **`IsEligible: true`, no restriction.** The item is open to any provider, so no specialty gate applies.
- **`IsEligible: false`.** None of the provider's specialties may render the item; the `Reason` lists the provider's specialties alongside the eligible ones, so the gap is explicit.

Where an item carries a further condition the API cannot confirm from a provider number (a credential, supervision, or accreditation rule), the `Reason` appends a "verify separately" note with its MBS reference, so nothing is silently assumed.

#### Status codes

- `200`: eligibility determined; read `IsEligible` and `Reason`.
- `404`: the `providerNumber` or `itemNumber` was not found. The body is plain text (see the `404` example).


Reference: https://docs.rebateright.com.au/api-reference/providers/servicing-provider-eligibility

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /Providers/{providerNumber}/ServicingEligibility/{itemNumber}:
    get:
      operationId: Servicing Provider Eligibility
      summary: Servicing Provider Eligibility
      description: >
        Checks whether a **servicing (rendering) provider** may perform and
        claim a given MBS item. It runs *before* the claim is lodged, so a
        wrong-provider rejection is caught up front rather than at assessment.


        The check runs entirely within RebateRight: no Medicare call and no
        patient details, only a `providerNumber` and an `itemNumber`. That makes
        it fast enough to validate every line of a batch and safe to run with no
        patient data in play.


        <CardGroup cols={1}>

        <Card title="Provider Atlas: every specialty and credential"
        icon="sitemap" href="/provider-atlas">

        Every eligibility answer rests on the recognition Medicare holds for the
        provider. The Provider Atlas maps them all, and shows how the same
        recognitions decide who may render, claim, and refer each item.

        </Card>

        </CardGroup>


        #### The sources behind every check


        RebateRight resolves the answer from the authoritative sources that
        govern who may render an item:


        <CardGroup cols={2}>

        <Card title="Provider recognitions">The specialties, fields and
        credentials Medicare recognises for the provider, expanded through
        RebateRight's recognition hierarchy so that allowing a broad class (such
        as a specialist medical practitioner) automatically covers every
        sub-specialty beneath it.</Card>

        <Card title="MBS item structure">The item's MBS category, group and
        sub-group (the layered structure mapped to eligible specialties),
        together with the item's own descriptor, which can override the group
        rule where an individual item is tighter or broader.</Card>

        <Card title="Legislative determinations">The Diagnostic Imaging,
        Pathology and General Medical Services Tables on the Federal Register:
        the legislation that sets, item by item, which providers may render and
        bill a service, beyond what the descriptor alone states.</Card>

        <Card title="MBS explanatory notes">Conditions a specialty alone cannot
        express, such as Approved Pathology Practitioner status,
        nuclear-medicine credentialling, or CT coronary angiography recognition.
        RebateRight surfaces these in the Reason as a "verify separately"
        pointer with its MBS reference.</Card>

        </CardGroup>


        To stay accurate, RebateRight continually reconciles its determinations
        against Medicare. The result is advisory: the binding decision is made
        when the claim is assessed.


        #### Reading the result


        A `200` always returns a boolean `IsEligible` and a plain-language
        `Reason`. Three shapes come back:


        - **`IsEligible: true` with a specialty named.** One of the provider's
        specialties may render the item; the `Reason` names the matching
        specialty and the MBS group or item rule it satisfied.

        - **`IsEligible: true`, no restriction.** The item is open to any
        provider, so no specialty gate applies.

        - **`IsEligible: false`.** None of the provider's specialties may render
        the item; the `Reason` lists the provider's specialties alongside the
        eligible ones, so the gap is explicit.


        Where an item carries a further condition the API cannot confirm from a
        provider number (a credential, supervision, or accreditation rule), the
        `Reason` appends a "verify separately" note with its MBS reference, so
        nothing is silently assumed.


        #### Status codes


        - `200`: eligibility determined; read `IsEligible` and `Reason`.

        - `404`: the `providerNumber` or `itemNumber` was not found. The body is
        plain text (see the `404` example).
      tags:
        - providers
      parameters:
        - name: providerNumber
          in: path
          description: >-
            The servicing provider's Medicare provider number, exactly as issued
            (case-sensitive, including the location and check-digit characters).
          required: true
          schema:
            type: string
        - name: itemNumber
          in: path
          description: The MBS item number being checked.
          required: true
          schema:
            type: string
        - name: x-api-key
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Eligibility was determined.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Providers_Servicing Provider
                  Eligibility_Response_200
        '404':
          description: >
            The `providerNumber` or `itemNumber` was not found.


            **Wire format:** the body is plain text (`text/plain`, UTF-8), not
            JSON. The example shows the verbatim message. OpenAPI lists it under
            `application/json` with `schema: string` only so the API explorer
            can render the example.
          content:
            application/json:
              schema:
                type: string
servers:
  - url: https://api.rebateright.com.au
    description: Production
  - url: https://test-api.rebateright.com.au
    description: Test
components:
  schemas:
    Providers_Servicing Provider Eligibility_Response_200:
      type: object
      properties:
        IsEligible:
          type: boolean
          description: Whether the provider is eligible to perform and claim the item.
        Reason:
          type: string
          description: >-
            Plain-language explanation of the eligibility decision, naming the
            matching or eligible specialties, the MBS group or item rule
            applied, and any "verify separately" note.
      required:
        - IsEligible
        - Reason
      title: Providers_Servicing Provider Eligibility_Response_200
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
    minorId:
      type: apiKey
      in: header
      name: x-minor-id

```

## Examples

### Eligible (item rule)



**Response**

```json
{
  "IsEligible": true,
  "Reason": "An 'Audiologist' may render this Medicare item. MBS item 10952 — audiology service, rendered by an audiologist."
}
```

**SDK Code**

```python Eligible (item rule)
import requests

url = "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Eligible (item rule)
const url = 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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

```go Eligible (item rule)
package main

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

func main() {

	url := "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Eligible (item rule)
require 'uri'
require 'net/http'

url = URI("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Eligible (item rule)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Eligible (item rule)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Eligible (item rule)
using RestSharp;

var client = new RestClient("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Eligible (item rule)
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")! 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()
```

### Eligible (group rule)



**Response**

```json
{
  "IsEligible": true,
  "Reason": "An 'Audiologist' may render this Medicare item. MBS Category 8, Group M15 — diagnostic audiology services."
}
```

**SDK Code**

```python Eligible (group rule)
import requests

url = "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Eligible (group rule)
const url = 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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

```go Eligible (group rule)
package main

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

func main() {

	url := "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Eligible (group rule)
require 'uri'
require 'net/http'

url = URI("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Eligible (group rule)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Eligible (group rule)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Eligible (group rule)
using RestSharp;

var client = new RestClient("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Eligible (group rule)
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")! 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()
```

### Not eligible



**Response**

```json
{
  "IsEligible": false,
  "Reason": "The provider is not eligible to render this Medicare item. Provider specialties: [ 'Physiotherapist' ]. Specialties eligible to render this item: [ 'General Practitioner' ]. MBS Category 1, Group A1 — general practitioner attendances."
}
```

**SDK Code**

```python Not eligible
import requests

url = "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Not eligible
const url = 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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

```go Not eligible
package main

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

func main() {

	url := "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Not eligible
require 'uri'
require 'net/http'

url = URI("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Not eligible
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Not eligible
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Not eligible
using RestSharp;

var client = new RestClient("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Not eligible
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")! 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()
```

### Not eligible (note)



**Response**

```json
{
  "IsEligible": false,
  "Reason": "The provider is not eligible to render this Medicare item. Provider specialties: [ 'Audiologist' ]. Specialties eligible to render this item: [ 'Specialist pathologist' ]. MBS Category 6, Group P2 — chemical pathology. Benefits also require the service to be performed by an Approved Pathology Practitioner in an Approved Pathology Authority's accredited laboratory — verify separately (MBS note PN.1.1)."
}
```

**SDK Code**

```python Not eligible (note)
import requests

url = "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript Not eligible (note)
const url = 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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

```go Not eligible (note)
package main

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

func main() {

	url := "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby Not eligible (note)
require 'uri'
require 'net/http'

url = URI("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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

```java Not eligible (note)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php Not eligible (note)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Not eligible (note)
using RestSharp;

var client = new RestClient("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Not eligible (note)
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")! 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()
```

### No restriction



**Response**

```json
{
  "IsEligible": true,
  "Reason": "Any provider may render this Medicare item. No servicing-provider restriction is recorded for this item's MBS group."
}
```

**SDK Code**

```python No restriction
import requests

url = "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

headers = {"x-api-key": "<apiKey>"}

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

print(response.json())
```

```javascript No restriction
const url = 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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

```go No restriction
package main

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

func main() {

	url := "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952"

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

	req.Header.Add("x-api-key", "<apiKey>")

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

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

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

}
```

```ruby No restriction
require 'uri'
require 'net/http'

url = URI("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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

```java No restriction
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")
  .header("x-api-key", "<apiKey>")
  .asString();
```

```php No restriction
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp No restriction
using RestSharp;

var client = new RestClient("https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift No restriction
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.rebateright.com.au/Providers/2446081F/ServicingEligibility/10952")! 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()
```