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

# Fetch Dedupe Results

GET https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/{borrowerProviderID}/journey/dedupe

See the outcome of the borrower's Dedupe check, with a clear view of the overall journey and each participating lender's result.

The response shows which lenders have cleared the borrower to continue, which have not, and whether any checks are still underway. When the check is complete, use the same journey ID to move into Eligibility or **Create A Journey** with the lending partners available to the borrower.

Reference: https://docs.credit.aarthiklabs.com/api-reference/hybrid-experience/business-loan/read-hybrid-business-loan-dedupe

## Authentication

- `Authorization` header (bearer token, required) — Send `Authorization: Bearer <PLATFORM_API_KEY>` from a trusted back-end.

## Servers

- `https://credit.aarthiklabs.com` (Production, default)
- `https://preprod.credit.aarthiklabs.com` (PreProduction)

## Request

### Path parameters

- `borrowerProviderID` (string, required) — Stable borrower identity from the partner system. Keep a 1:1 mapping between the borrower and `borrowerProviderID` across sessions and application attempts to preserve resume, history, and post-disbursal continuity.

### Query parameters

- `journeyID` (string, required) — Business Loan journey ID. Supply this parameter exactly once on Dedupe polling or Eligibility; additional query parameters are not accepted.

### Headers

- `x-correlation-id` (string, optional) — Optional caller-supplied trace identifier. When omitted, the API generates one and mirrors it as `correlation_id`.

## Response

### 200

Current operation progress and lender results.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (HybridBusinessDedupeResult, required)
- `error` (any, required)

## Errors

### 400 Bad Request Error

Request body or path validation failed.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### 401 Unauthorized Error

Missing or invalid platform API key.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### 403 Forbidden Error

Business Hybrid bundle creation is disabled for the authenticated application. Exact retries of an existing bundle remain resumable.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### 404 Not Found Error

Borrower, journey, route, or offer was not found for the authenticated application scope.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### 409 Conflict Error

The current journey or offer state does not allow the requested transition.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### 429 Too Many Requests Error

Too many requests. For offer polling, retry at the returned `polling.nextPoll` timestamp.

- `ReadHybridBusinessLoanDedupeRequestTooManyRequestsError`
  - HybridErrorResponse: HybridErrorResponse
  - HybridOfferPollingRateLimitedResponse: HybridOfferPollingRateLimitedResponse

### 500 Internal Server Error

Temporary upstream or platform failure.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### 503 Service Unavailable Error

Temporary upstream or platform failure.

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

## Types

### HybridBusinessDedupeResult

- `journeyID` (string, required)
- `stage` ("DEDUPE", required)
- `status` (enum, required) — Journey-level outcome: PENDING if any lender is pending; otherwise CLEAR if any lender is CLEAR or SKIPPED; otherwise NOT_CLEAR. ERROR counts as negative. Lender-level statuses remain unchanged.
  - Allowed values: `CLEAR`, `NOT_CLEAR`, `PENDING`
- `lenders` (list of HybridBusinessDedupeLenderResult, required)
- `polling` (HybridBusinessOperationPolling, required)

### HybridError

- `code` (enum, required)
  - Allowed values: `VALIDATION_FAILED`, `AUTH_INVALID_API_KEY`, `AUTH_INVALID_SESSION`, `ACCESS_SCOPE_MISMATCH`, `RESOURCE_NOT_FOUND`, `OFFER_LOCK_CONFLICT`, `STATE_PRECONDITION_FAILED`, `OFFER_POLL_RATE_LIMITED`, `HYBRID_JOURNEY_NOT_READY`, `RATE_LIMITED`, `UPSTREAM_TEMPORARY_FAILURE`
- `message` (string, required)
- `retryable` (boolean, required) — Whether retrying the same operation can make progress. A persisted final primary-form failure is not retryable, including HTTP 500; reconcile the accepted operation before any resubmission. Correct invalid input before retrying validation failures.
- `details` (map from string to any, required, nullable)

### HybridErrorResponse

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (any, required)
- `error` (HybridError, required)

### HybridOfferPollingRateLimitedResponse

- `request_id` (string, required)
- `correlation_id` (string, required)
- `timestamp` (datetime, required)
- `data` (HybridOfferPollingRateLimitedResponseData, required)
- `error` (HybridError, required)

### HybridBusinessDedupeLenderResult

- `lenderID` (string, required)
- `status` (enum, required) — PENDING: awaiting a result; CLEAR: passes the check; NOT_CLEAR: does not pass; SKIPPED: check not required; ERROR: check failed technically, not a borrower rejection.
  - Allowed values: `CLEAR`, `NOT_CLEAR`, `SKIPPED`, `ERROR`, `PENDING`
- `decisionReference` (string, required, nullable) — Opaque reference for the lender decision, when available.
- `decidedAt` (datetime, required, nullable)
- `expiresAt` (datetime, required, nullable)
- `reasonCode` (string, required, nullable) — Safe reason code when available. Null if the lender did not supply one.

### HybridBusinessOperationPolling

- `shouldPoll` (boolean, required) — Continue GET reads only while true.
- `lastPoll` (datetime, required, nullable)
- `nextPoll` (datetime, required, nullable) — Earliest time for the next GET. Null when polling has stopped.

### HybridOfferPollingRateLimitedResponseData

- `polling` (HybridPolling, required)

### HybridPolling

- `shouldPoll` (boolean, required)
- `lastPoll` (datetime, required)
- `nextPoll` (datetime, required)

## Examples

### Pending — awaiting lenders

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "PENDING",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "PENDING",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "PENDING",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": true,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": "2026-10-28T09:00:10Z"
    }
  },
  "error": null
}
```

**SDK Code**

```python Pending — awaiting lenders
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript Pending — awaiting lenders
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Pending — awaiting lenders
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Pending — awaiting lenders
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java Pending — awaiting lenders
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Pending — awaiting lenders
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Pending — awaiting lenders
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Pending — awaiting lenders
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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()
```

### Pending — one lender clear

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "PENDING",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "CLEAR",
        "decisionReference": "decision-example-1",
        "decidedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "PENDING",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": true,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": "2026-10-28T09:00:10Z"
    }
  },
  "error": null
}
```

**SDK Code**

```python Pending — one lender clear
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript Pending — one lender clear
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Pending — one lender clear
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby Pending — one lender clear
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java Pending — one lender clear
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Pending — one lender clear
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Pending — one lender clear
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Pending — one lender clear
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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()
```

### CLEAR — no pending lenders

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "CLEAR",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "CLEAR",
        "decisionReference": "decision-example-1",
        "decidedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "NOT_CLEAR",
        "decisionReference": "decision-example-2",
        "decidedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    }
  },
  "error": null
}
```

**SDK Code**

```python CLEAR — no pending lenders
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript CLEAR — no pending lenders
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go CLEAR — no pending lenders
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby CLEAR — no pending lenders
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java CLEAR — no pending lenders
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php CLEAR — no pending lenders
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp CLEAR — no pending lenders
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift CLEAR — no pending lenders
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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_CLEAR — all lenders negative

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "NOT_CLEAR",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "NOT_CLEAR",
        "decisionReference": "decision-example-1",
        "decidedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "NOT_CLEAR",
        "decisionReference": "decision-example-2",
        "decidedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    }
  },
  "error": null
}
```

**SDK Code**

```python NOT_CLEAR — all lenders negative
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript NOT_CLEAR — all lenders negative
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go NOT_CLEAR — all lenders negative
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby NOT_CLEAR — all lenders negative
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java NOT_CLEAR — all lenders negative
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php NOT_CLEAR — all lenders negative
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp NOT_CLEAR — all lenders negative
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift NOT_CLEAR — all lenders negative
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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()
```

### CLEAR — all lenders skipped

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "CLEAR",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "SKIPPED",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "SKIPPED",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    }
  },
  "error": null
}
```

**SDK Code**

```python CLEAR — all lenders skipped
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript CLEAR — all lenders skipped
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go CLEAR — all lenders skipped
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby CLEAR — all lenders skipped
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java CLEAR — all lenders skipped
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php CLEAR — all lenders skipped
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp CLEAR — all lenders skipped
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift CLEAR — all lenders skipped
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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_CLEAR — all lenders errored

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "NOT_CLEAR",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "ERROR",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "ERROR",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    }
  },
  "error": null
}
```

**SDK Code**

```python NOT_CLEAR — all lenders errored
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript NOT_CLEAR — all lenders errored
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go NOT_CLEAR — all lenders errored
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby NOT_CLEAR — all lenders errored
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java NOT_CLEAR — all lenders errored
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php NOT_CLEAR — all lenders errored
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp NOT_CLEAR — all lenders errored
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift NOT_CLEAR — all lenders errored
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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_CLEAR — negative and error

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "NOT_CLEAR",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "NOT_CLEAR",
        "decisionReference": "decision-example-1",
        "decidedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "ERROR",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    }
  },
  "error": null
}
```

**SDK Code**

```python NOT_CLEAR — negative and error
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript NOT_CLEAR — negative and error
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go NOT_CLEAR — negative and error
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby NOT_CLEAR — negative and error
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java NOT_CLEAR — negative and error
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php NOT_CLEAR — negative and error
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp NOT_CLEAR — negative and error
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift NOT_CLEAR — negative and error
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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()
```

### CLEAR — skipped and error

**Response**

```json
{
  "request_id": "30000000-0000-4000-8000-000000000001",
  "correlation_id": "40000000-0000-4000-8000-000000000001",
  "timestamp": "2026-10-28T09:00:00Z",
  "data": {
    "journeyID": "10000000-0000-4000-8000-000000000001",
    "stage": "DEDUPE",
    "status": "CLEAR",
    "lenders": [
      {
        "lenderID": "example-lender-a",
        "status": "SKIPPED",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      },
      {
        "lenderID": "example-lender-b",
        "status": "ERROR",
        "decisionReference": null,
        "decidedAt": null,
        "expiresAt": null,
        "reasonCode": null
      }
    ],
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    }
  },
  "error": null
}
```

**SDK Code**

```python CLEAR — skipped and error
import requests

url = "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe"

querystring = {"journeyID":"10000000-0000-4000-8000-000000000001"}

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

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

print(response.json())
```

```javascript CLEAR — skipped and error
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go CLEAR — skipped and error
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby CLEAR — skipped and error
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")

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

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

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

```java CLEAR — skipped and error
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php CLEAR — skipped and error
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp CLEAR — skipped and error
using RestSharp;

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift CLEAR — skipped and error
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/dedupe?journeyID=10000000-0000-4000-8000-000000000001")! 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()
```