# 1. Verify Patient

POST https://VerifyPatient
Content-Type: application/json

This endpoint receives patient details and verifies patient information with Medicare.

### 🎨 How It Works

- First RebateRight validates the inputs for expected format and required information.
    
- Then it Uses Medicare Patient Verification Check service behind the scenes to provide the results.
    
- The response may include correct data if there is a mismatch.
    

### 🛠️ Example Requests and Responses

To explore sample requests and responses, go to the Example Request section and use the options in the top-right corner to view different requests along with their corresponding responses from RebateRight.

<img src="https://content.pstmn.io/b64ccbc5-883c-4818-963f-5ac86cfa065f/aW1hZ2UucG5n" alt="How%20to%20Choose%20a%20Sample%20Request" width="100%">

### 🔍 Medicare Verification Process

#### 🪪 Medicare Card Number

If the Medicare card number is incorrect, verification fails. Medicare does not return corrected information.

**Response**

> The card number and/or patient details submitted did not match Medicare checks. Please verify the details and resubmit with additional information if available. 
  

#### 🎂 Date of Birth

If the date of birth is the only incorrect field, Medicare will indicate that the DOB is incorrect, but does not return the correct value.

**Response**

> Patient Verification has been accepted however patient details were not an exact match. Please check patient Date of Birth before claiming. 
  

If other fields are also incorrect, verification fails and no corrections are provided.

**Response**

> The card number and/or patient details submitted did not match Medicare checks. Please verify the details and resubmit with additional information if available. 
  

#### 🔢 Medicare Reference Number

If this is the only incorrect field, Medicare returns the correct reference number to help you correct it.

**Response**

> Patient Verification has been accepted however patient details were not an exact match. Please check patient Individual Reference Number (IRN) before claiming. Correct Medicare Reference Number: 3. 
  

If other fields are also incorrect, verification fails and no corrections are provided.

**Response**

> The card number and/or patient details submitted did not match Medicare checks. Please verify the details and resubmit with additional information if available. 
  

#### 🧑 Given Name

Medicare validates the **first five characters of the patient’s given name**. If these match Medicare records, the request can still be accepted even if the full given name differs. **Example:** Submitted: **ELIZA** Medicare record: **ELIZABETH** This will be accepted.  
  
If the given name is the only incorrect field, Medicare returns the correct given name to assist with updating records.

**Response**

> Patient Verification has been accepted however patient details were not an exact match. Please check patient Given Name before claiming. Correct Given Name: CLINT. 
  

If other fields are also incorrect, verification fails and no corrections are provided.

**Response**

> The card number and/or patient details submitted did not match Medicare checks. Please verify the details and resubmit with additional information if available. 
  

#### 👪 Family Name & Sex

These fields are optional. If one or both of them are incorrect, verification still succeeds. Medicare ignores mismatches in these fields and does not report or correct them.

**Response**

> "Patient is eligible to claim for Medicare with details provided." 
  

#### 🆕 New Medicare Card Issued

if a new Medicare card has been issued for the patient, Medicare provides the correct Medicare Number, Reference Number, and Given Name.

**Response**

> A new Medicare card has been issued. Please confirm your records with the patient and if required update for any future claims. Correct Medicare Number: 6951393352. Correct Medicare Reference Number: 2. Correct Given Name: SAM."

Reference: https://developers.rebateright.com.au/rebate-right/standard-eligibility-flow/1-verify-patient

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /VerifyPatient:
    post:
      operationId: 1-verify-patient
      summary: 1. Verify Patient
      description: >-
        This endpoint receives patient details and verifies patient information
        with Medicare.


        ### 🎨 How It Works


        - First RebateRight validates the inputs for expected format and
        required information.
            
        - Then it Uses Medicare Patient Verification Check service behind the
        scenes to provide the results.
            
        - The response may include correct data if there is a mismatch.
            

        ### 🛠️ Example Requests and Responses


        To explore sample requests and responses, go to the Example Request
        section and use the options in the top-right corner to view different
        requests along with their corresponding responses from RebateRight.


        <img
        src="https://content.pstmn.io/b64ccbc5-883c-4818-963f-5ac86cfa065f/aW1hZ2UucG5n"
        alt="How%20to%20Choose%20a%20Sample%20Request" width="100%">


        ### 🔍 Medicare Verification Process


        #### 🪪 Medicare Card Number


        If the Medicare card number is incorrect, verification fails. Medicare
        does not return corrected information.


        **Response**


        > The card number and/or patient details submitted did not match
        Medicare checks. Please verify the details and resubmit with additional
        information if available. 
          

        #### 🎂 Date of Birth


        If the date of birth is the only incorrect field, Medicare will indicate
        that the DOB is incorrect, but does not return the correct value.


        **Response**


        > Patient Verification has been accepted however patient details were
        not an exact match. Please check patient Date of Birth before claiming. 
          

        If other fields are also incorrect, verification fails and no
        corrections are provided.


        **Response**


        > The card number and/or patient details submitted did not match
        Medicare checks. Please verify the details and resubmit with additional
        information if available. 
          

        #### 🔢 Medicare Reference Number


        If this is the only incorrect field, Medicare returns the correct
        reference number to help you correct it.


        **Response**


        > Patient Verification has been accepted however patient details were
        not an exact match. Please check patient Individual Reference Number
        (IRN) before claiming. Correct Medicare Reference Number: 3. 
          

        If other fields are also incorrect, verification fails and no
        corrections are provided.


        **Response**


        > The card number and/or patient details submitted did not match
        Medicare checks. Please verify the details and resubmit with additional
        information if available. 
          

        #### 🧑 Given Name


        Medicare validates the **first five characters of the patient’s given
        name**. If these match Medicare records, the request can still be
        accepted even if the full given name differs. **Example:** Submitted:
        **ELIZA** Medicare record: **ELIZABETH** This will be accepted.  
          
        If the given name is the only incorrect field, Medicare returns the
        correct given name to assist with updating records.


        **Response**


        > Patient Verification has been accepted however patient details were
        not an exact match. Please check patient Given Name before claiming.
        Correct Given Name: CLINT. 
          

        If other fields are also incorrect, verification fails and no
        corrections are provided.


        **Response**


        > The card number and/or patient details submitted did not match
        Medicare checks. Please verify the details and resubmit with additional
        information if available. 
          

        #### 👪 Family Name & Sex


        These fields are optional. If one or both of them are incorrect,
        verification still succeeds. Medicare ignores mismatches in these fields
        and does not report or correct them.


        **Response**


        > "Patient is eligible to claim for Medicare with details provided." 
          

        #### 🆕 New Medicare Card Issued


        if a new Medicare card has been issued for the patient, Medicare
        provides the correct Medicare Number, Reference Number, and Given Name.


        **Response**


        > A new Medicare card has been issued. Please confirm your records with
        the patient and if required update for any future claims. Correct
        Medicare Number: 6951393352. Correct Medicare Reference Number: 2.
        Correct Given Name: SAM."
      tags:
        - subpackage_standardEligibilityFlow
      parameters:
        - name: x-api-key
          in: header
          required: true
          schema:
            type: string
        - name: x-minor-id
          in: header
          required: false
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Standard Eligibility Flow_1. Verify
                  Patient_Response_200
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                PatientSex:
                  type: string
                PatientGivenName:
                  type: string
                PatientFamilyName:
                  type: string
                PatientDateOfBirth:
                  type: string
                  format: date
                PatientMedicareNumber:
                  type: string
                PatientMedicareRefNumber:
                  type: string
              required:
                - PatientSex
                - PatientGivenName
                - PatientFamilyName
                - PatientDateOfBirth
                - PatientMedicareNumber
                - PatientMedicareRefNumber
servers:
  - url: https:/
components:
  schemas:
    Standard Eligibility Flow_1. Verify Patient_Response_200:
      type: object
      properties:
        Reason:
          type: string
        Verified:
          type: boolean
        CorrectSex:
          description: Any type
        CorrectGivenName:
          description: Any type
        CorrectFamilyName:
          description: Any type
        CorrectDateOfBirth:
          description: Any type
        CorrectMedicareNumber:
          description: Any type
        CorrectMedicareReferenceNumber:
          description: Any type
      required:
        - Reason
        - Verified
      title: Standard Eligibility Flow_1. Verify Patient_Response_200
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

```

## SDK Code Examples

```python Success
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Success
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Success
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Success
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Success
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Success
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python OnlyName
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript OnlyName
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go OnlyName
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby OnlyName
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java OnlyName
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp OnlyName
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift OnlyName
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Deceased Patient
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Deceased Patient
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Deceased Patient
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Deceased Patient
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Deceased Patient
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Deceased Patient
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Deceased Patient
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Deceased Patient
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python New Medicare Card
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript New Medicare Card
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go New Medicare Card
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby New Medicare Card
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java New Medicare Card
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php New Medicare Card
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp New Medicare Card
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift New Medicare Card
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect GivenName
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect GivenName
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect GivenName
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect GivenName
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect GivenName
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect GivenName
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect GivenName
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect GivenName
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Missing DateOfBirth
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Missing DateOfBirth
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Missing DateOfBirth
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Missing DateOfBirth
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Missing DateOfBirth
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Missing DateOfBirth
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Missing DateOfBirth
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Missing DateOfBirth
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Invalid MedicareNumber
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Invalid MedicareNumber
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Invalid MedicareNumber
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Invalid MedicareNumber
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Invalid MedicareNumber
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Invalid MedicareNumber
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Invalid MedicareNumber
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Invalid MedicareNumber
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect Date of Birth
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect Date of Birth
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect Date of Birth
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect Date of Birth
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect Date of Birth
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect Date of Birth
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect Date of Birth
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect Date of Birth
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect Medicare Number
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect Medicare Number
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect Medicare Number
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect Medicare Number
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect Medicare Number
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect Medicare Number
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect Medicare Number
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect Medicare Number
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect ReferenceNumber
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect ReferenceNumber
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect ReferenceNumber
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect ReferenceNumber
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect ReferenceNumber
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect ReferenceNumber
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect ReferenceNumber
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect ReferenceNumber
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect Gender (Accepted)
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect Gender (Accepted)
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect Gender (Accepted)
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect Gender (Accepted)
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect Gender (Accepted)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect Gender (Accepted)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect Gender (Accepted)
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect Gender (Accepted)
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect Gender & Given Name
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect Gender & Given Name
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect Gender & Given Name
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect Gender & Given Name
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect Gender & Given Name
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect Gender & Given Name
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect Gender & Given Name
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect Gender & Given Name
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect Given & Family name
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect Given & Family name
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect Given & Family name
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect Given & Family name
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect Given & Family name
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect Given & Family name
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect Given & Family name
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect Given & Family name
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect FamilyName (Accepted)
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect FamilyName (Accepted)
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect FamilyName (Accepted)
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect FamilyName (Accepted)
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect FamilyName (Accepted)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect FamilyName (Accepted)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect FamilyName (Accepted)
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect FamilyName (Accepted)
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Incorrect Gender & Family name (Accepted)
import requests

url = "https://https/VerifyPatient"

headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Incorrect Gender & Family name (Accepted)
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: undefined
};

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

```go Incorrect Gender & Family name (Accepted)
package main

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

func main() {

	url := "https://https/VerifyPatient"

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

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Incorrect Gender & Family name (Accepted)
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'

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

```java Incorrect Gender & Family name (Accepted)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Incorrect Gender & Family name (Accepted)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Incorrect Gender & Family name (Accepted)
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Incorrect Gender & Family name (Accepted)
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! 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()
```

```python Standard Eligibility Flow_1. Verify Patient_example
import requests

url = "https://https/VerifyPatient"

payload = {
    "PatientSex": "1",
    "PatientGivenName": "Edmond",
    "PatientFamilyName": "FLETCHER",
    "PatientDateOfBirth": "1986-12-18",
    "PatientMedicareNumber": "4951525561",
    "PatientMedicareRefNumber": "2"
}
headers = {
    "x-minor-id": "{{MinorId}}",
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Standard Eligibility Flow_1. Verify Patient_example
const url = 'https://https/VerifyPatient';
const options = {
  method: 'POST',
  headers: {
    'x-minor-id': '{{MinorId}}',
    'x-api-key': '<apiKey>',
    'Content-Type': 'application/json'
  },
  body: '{"PatientSex":"1","PatientGivenName":"Edmond","PatientFamilyName":"FLETCHER","PatientDateOfBirth":"1986-12-18","PatientMedicareNumber":"4951525561","PatientMedicareRefNumber":"2"}'
};

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

```go Standard Eligibility Flow_1. Verify Patient_example
package main

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

func main() {

	url := "https://https/VerifyPatient"

	payload := strings.NewReader("{\n  \"PatientSex\": \"1\",\n  \"PatientGivenName\": \"Edmond\",\n  \"PatientFamilyName\": \"FLETCHER\",\n  \"PatientDateOfBirth\": \"1986-12-18\",\n  \"PatientMedicareNumber\": \"4951525561\",\n  \"PatientMedicareRefNumber\": \"2\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-minor-id", "{{MinorId}}")
	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Standard Eligibility Flow_1. Verify Patient_example
require 'uri'
require 'net/http'

url = URI("https://https/VerifyPatient")

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

request = Net::HTTP::Post.new(url)
request["x-minor-id"] = '{{MinorId}}'
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"PatientSex\": \"1\",\n  \"PatientGivenName\": \"Edmond\",\n  \"PatientFamilyName\": \"FLETCHER\",\n  \"PatientDateOfBirth\": \"1986-12-18\",\n  \"PatientMedicareNumber\": \"4951525561\",\n  \"PatientMedicareRefNumber\": \"2\"\n}"

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

```java Standard Eligibility Flow_1. Verify Patient_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/VerifyPatient")
  .header("x-minor-id", "{{MinorId}}")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"PatientSex\": \"1\",\n  \"PatientGivenName\": \"Edmond\",\n  \"PatientFamilyName\": \"FLETCHER\",\n  \"PatientDateOfBirth\": \"1986-12-18\",\n  \"PatientMedicareNumber\": \"4951525561\",\n  \"PatientMedicareRefNumber\": \"2\"\n}")
  .asString();
```

```php Standard Eligibility Flow_1. Verify Patient_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/VerifyPatient', [
  'body' => '{
  "PatientSex": "1",
  "PatientGivenName": "Edmond",
  "PatientFamilyName": "FLETCHER",
  "PatientDateOfBirth": "1986-12-18",
  "PatientMedicareNumber": "4951525561",
  "PatientMedicareRefNumber": "2"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
    'x-minor-id' => '{{MinorId}}',
  ],
]);

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

```csharp Standard Eligibility Flow_1. Verify Patient_example
using RestSharp;

var client = new RestClient("https://https/VerifyPatient");
var request = new RestRequest(Method.POST);
request.AddHeader("x-minor-id", "{{MinorId}}");
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"PatientSex\": \"1\",\n  \"PatientGivenName\": \"Edmond\",\n  \"PatientFamilyName\": \"FLETCHER\",\n  \"PatientDateOfBirth\": \"1986-12-18\",\n  \"PatientMedicareNumber\": \"4951525561\",\n  \"PatientMedicareRefNumber\": \"2\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Standard Eligibility Flow_1. Verify Patient_example
import Foundation

let headers = [
  "x-minor-id": "{{MinorId}}",
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "PatientSex": "1",
  "PatientGivenName": "Edmond",
  "PatientFamilyName": "FLETCHER",
  "PatientDateOfBirth": "1986-12-18",
  "PatientMedicareNumber": "4951525561",
  "PatientMedicareRefNumber": "2"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://https/VerifyPatient")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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