> 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 Eligibility Results

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

Bring the borrower's eligibility assessment into view, with an overall journey result and a separate decision from each participating lender.

Where available, eligible lender results include an indicative loan amount, interest rate, annual percentage rate and repayment term. These provisional terms help the borrower understand the possibilities before exploring available offers; they are not a final loan approval.

Continue with **Create A Journey** using the same journey ID to discover offers for the borrower.

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

## 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` (HybridBusinessEligibilityData, 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 Loan Eligibility is disabled or not entitled for the authenticated buyer application.

- `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.

- `ReadHybridBusinessLoanEligibilityRequestTooManyRequestsError`
  - 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

### HybridBusinessEligibilityData

- `journeyID` (string, required) — Public borrower journey ID. Reuse this value for Create A Journey, offer polling and handoff.
- `stage` (enum, required)
  - Allowed values: `ELIGIBILITY`
- `attemptID` (string, required) — Opaque Eligibility attempt identifier for support and replay correlation.
- `status` (enum, required) — Overall result for this journey, computed from all lender decisions.
  - Allowed values: `ELIGIBLE`, `NOT_ELIGIBLE`, `PENDING`
- `expiresAt` (datetime, required)
- `lenders` (list of HybridBusinessEligibilityLenderResult, required)
- `summary` (HybridBusinessEligibilitySummary, required)
- `polling` (HybridBusinessEligibilityPolling, required)
- `replayed` (boolean, required) — True when this response was served from an existing attempt for the same current input.

### 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)

### HybridBusinessEligibilityLenderResult

Lender-specific preliminary assessment with indicative terms when available. These terms are provisional, not a sanctioned loan or an actionable final offer. Continue through Create A Journey and offer selection before requesting a Hosted handoff.

- `lenderID` (string, required) — Stable public lender identifier configured for this buyer application.
- `lenderName` (string, required) — Display name for the enabled lender.
- `decision` (enum, required) — Lender-level eligibility: ELIGIBLE, NOT_ELIGIBLE, SKIPPED, ERROR or PENDING.
  - Allowed values: `ELIGIBLE`, `NOT_ELIGIBLE`, `SKIPPED`, `ERROR`, `PENDING`
- `reasonCode` (string, required, nullable) — Stable non-sensitive reason code. No BRE trace or bureau facts are returned.
- `retryable` (boolean, required)
- `evaluatedAt` (datetime, required, nullable)
- `expiresAt` (datetime, required, nullable)
- `annualPercentageRate` (string, required, nullable) — Indicative annual percentage rate, expressed as a percentage string, not a fraction. Null when no indicative terms are available.
- `interestRate` (string, required, nullable) — Indicative annual interest rate, expressed as a percentage string. This is distinct from APR. Null when unavailable.
- `amountPrincipal` (string, required, nullable) — Indicative principal amount in INR, as a decimal string. Null when unavailable; null does not mean zero.
- `offerTerm` (string, required, nullable) — Indicative repayment term, including the unit, consistent with offer responses. Null when unavailable.

### HybridBusinessEligibilitySummary

- `total` (integer, required)
- `eligible` (integer, required)
- `ineligible` (integer, required)
- `reviewRequired` (integer, required)
- `error` (integer, required)
- `skipped` (integer, required)
- `pending` (integer, required)

### HybridBusinessEligibilityPolling

- `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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "PENDING",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "PENDING",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "PENDING",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 0,
      "ineligible": 0,
      "reviewRequired": 0,
      "error": 0,
      "skipped": 0,
      "pending": 2
    },
    "polling": {
      "shouldPoll": true,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": "2026-10-28T09:00:10Z"
    },
    "replayed": false
  },
  "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/eligibility"

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/eligibility?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/eligibility?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/eligibility?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/eligibility?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/eligibility?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/eligibility?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/eligibility?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 eligible

**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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "PENDING",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "ELIGIBLE",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "annualPercentageRate": "18.50",
        "interestRate": "16.00",
        "amountPrincipal": "500000.00",
        "offerTerm": "12 months"
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "PENDING",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 1,
      "ineligible": 0,
      "reviewRequired": 0,
      "error": 0,
      "skipped": 0,
      "pending": 1
    },
    "polling": {
      "shouldPoll": true,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": "2026-10-28T09:00:10Z"
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python Pending — one lender eligible
import requests

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

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 eligible
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 eligible
package main

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

func main() {

	url := "https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 eligible
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 eligible
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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Pending — one lender eligible
<?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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

var client = new RestClient("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 eligible
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/eligibility?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()
```

### ELIGIBLE — 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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "ELIGIBLE",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "ELIGIBLE",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "annualPercentageRate": "18.50",
        "interestRate": "16.00",
        "amountPrincipal": "500000.00",
        "offerTerm": "12 months"
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "NOT_ELIGIBLE",
        "reasonCode": "BRE_RULE_REJECTED",
        "retryable": false,
        "evaluatedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 1,
      "ineligible": 1,
      "reviewRequired": 0,
      "error": 0,
      "skipped": 0,
      "pending": 0
    },
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python ELIGIBLE — no pending lenders
import requests

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

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

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

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

print(response.json())
```

```javascript ELIGIBLE — no pending lenders
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 ELIGIBLE — 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/eligibility?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 ELIGIBLE — no pending lenders
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

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

```swift ELIGIBLE — 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/eligibility?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_ELIGIBLE — 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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "NOT_ELIGIBLE",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "NOT_ELIGIBLE",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "NOT_ELIGIBLE",
        "reasonCode": "BRE_RULE_REJECTED",
        "retryable": false,
        "evaluatedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 0,
      "ineligible": 2,
      "reviewRequired": 0,
      "error": 0,
      "skipped": 0,
      "pending": 0
    },
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python NOT_ELIGIBLE — all lenders negative
import requests

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

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

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

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

print(response.json())
```

```javascript NOT_ELIGIBLE — all lenders negative
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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_ELIGIBLE — 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/eligibility?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_ELIGIBLE — all lenders negative
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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_ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php NOT_ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

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

```swift NOT_ELIGIBLE — 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/eligibility?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()
```

### ELIGIBLE — 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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "ELIGIBLE",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "SKIPPED",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "SKIPPED",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 0,
      "ineligible": 0,
      "reviewRequired": 0,
      "error": 0,
      "skipped": 2,
      "pending": 0
    },
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python ELIGIBLE — all lenders skipped
import requests

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

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

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

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

print(response.json())
```

```javascript ELIGIBLE — all lenders skipped
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 ELIGIBLE — 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/eligibility?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 ELIGIBLE — all lenders skipped
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

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

```swift ELIGIBLE — 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/eligibility?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_ELIGIBLE — 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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "NOT_ELIGIBLE",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "ERROR",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "ERROR",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 0,
      "ineligible": 0,
      "reviewRequired": 0,
      "error": 2,
      "skipped": 0,
      "pending": 0
    },
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python NOT_ELIGIBLE — all lenders errored
import requests

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

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

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

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

print(response.json())
```

```javascript NOT_ELIGIBLE — all lenders errored
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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_ELIGIBLE — 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/eligibility?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_ELIGIBLE — all lenders errored
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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_ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php NOT_ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

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

```swift NOT_ELIGIBLE — 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/eligibility?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_ELIGIBLE — 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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "NOT_ELIGIBLE",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "NOT_ELIGIBLE",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": "2026-10-28T09:00:00Z",
        "expiresAt": "2026-10-29T09:00:00Z",
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "ERROR",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 0,
      "ineligible": 1,
      "reviewRequired": 0,
      "error": 1,
      "skipped": 0,
      "pending": 0
    },
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python NOT_ELIGIBLE — negative and error
import requests

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

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

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

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

print(response.json())
```

```javascript NOT_ELIGIBLE — negative and error
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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_ELIGIBLE — 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/eligibility?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_ELIGIBLE — negative and error
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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_ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php NOT_ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

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

```swift NOT_ELIGIBLE — 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/eligibility?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()
```

### ELIGIBLE — 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": "ELIGIBILITY",
    "attemptID": "20000000-0000-4000-8000-000000000001",
    "status": "ELIGIBLE",
    "expiresAt": "2026-10-29T09:00:00Z",
    "lenders": [
      {
        "lenderID": "business_bank",
        "lenderName": "Business Bank",
        "decision": "SKIPPED",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      },
      {
        "lenderID": "growth_finance",
        "lenderName": "Growth Finance",
        "decision": "ERROR",
        "reasonCode": null,
        "retryable": false,
        "evaluatedAt": null,
        "expiresAt": null,
        "annualPercentageRate": null,
        "interestRate": null,
        "amountPrincipal": null,
        "offerTerm": null
      }
    ],
    "summary": {
      "total": 2,
      "eligible": 0,
      "ineligible": 0,
      "reviewRequired": 0,
      "error": 1,
      "skipped": 1,
      "pending": 0
    },
    "polling": {
      "shouldPoll": false,
      "lastPoll": "2026-10-28T09:00:00Z",
      "nextPoll": null
    },
    "replayed": false
  },
  "error": null
}
```

**SDK Code**

```python ELIGIBLE — skipped and error
import requests

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

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

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

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

print(response.json())
```

```javascript ELIGIBLE — skipped and error
const url = 'https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 ELIGIBLE — 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/eligibility?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 ELIGIBLE — skipped and error
require 'uri'
require 'net/http'

url = URI("https://credit.aarthiklabs.com/api/v1/hybrid/business-loan/borrowers/borrower-example-001/journey/eligibility?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 ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php ELIGIBLE — 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/eligibility?journeyID=10000000-0000-4000-8000-000000000001', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

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

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

```swift ELIGIBLE — 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/eligibility?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()
```