> For the complete documentation index, see [llms.txt](https://developers.bloomcredit.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developers.bloomcredit.io/docs/v2.1/quick-start/update-furnish-accounts.md).

# Update - Furnish Accounts

This page will help you get started with Bloom's Furnishment API.

## Credit Products

An Organization may offer various products to its customers, each with unique characteristics, such as loans, mortages, and credit cards.

Each product might offer different features, interest rates, and other terms when comparing the products. All these are updated by the Organizations through the Furnishment API.

### Create a Credit Product

Once you create a consumer, you can start creating and assigning credit products to them. The credit product details include the following:

* Name of the Credit Product
* Industry
* Portfolio Type
* Account Type
  * Refer to [CRRG](https://www.cdiaonline.org/publications/) Exhibit 1 for possible values
* Interest Type
* Terms frequency

Check out the [Create a credit product](https://developers.bloomcredit.io/v2.1/reference/create_credit_product_api_v1_credit_products__post) API reference to learn how to send a `POST` request to the Furnishment API with the credit product's information in the request body.

The response will include an ID (`credit_product_id`) that is used to identify the credit product uniquely.

### Credit Product Creation Example Request

You can see an example of a `POST` request made to the **Create Credit Product** endpoint below:

{% tabs %}
{% tab title="cURL" %}

```bash
curl --location --request POST 'https://sandbox.bloom.dev/v2/furnishment/credit-products/' \
--header 'Authorization: Bearer <ACCESS_TOKEN_WILL_BE_HERE>'\
--header 'Content-Type: application/json' \
--data-raw '{
    "data": {
        "type": "CreditProductCreateRequest",
        "attributes": {
            "name": "Example Credit Card",
            "industry": "CREDIT_CARD_ISSUER",
            "portfolio_type": "REVOLVING",
            "account_type": "SECURED_CREDIT_CARD",
            "interest_type": "VARIABLE",
            "terms_frequency": "MONTHLY"
        }
    }
}
'
```

{% endtab %}

{% tab title="HTTP" %}

```http
POST /v2/furnishment/credit-products/ HTTP/1.1
Host: sandbox.bloom.dev
Authorization: Bearer <ACCESS_TOKEN_WILL_BE_HERE>
Content-Type: application/json
Content-Length: 367

{
    "data": {
        "type": "CreditProductCreateRequest",
        "attributes": {
            "name": "Example Credit Card",
            "industry": "CREDIT_CARD_ISSUER",
            "portfolio_type": "REVOLVING",
            "account_type": "SECURED_CREDIT_CARD",
            "interest_type": "VARIABLE",
            "terms_frequency": "MONTHLY"
        }
    }
}

```

{% endtab %}

{% tab title="JavaScript - Fetch" %}

```javascript
var myHeaders = new Headers();
myHeaders.append("Authorization", "Bearer <ACCESS_TOKEN_WILL_BE_HERE>");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
  "data": {
    "type": "CreditProductCreateRequest",
    "attributes": {
      "name": "Example Credit Card",
      "industry": "CREDIT_CARD_ISSUER",
      "portfolio_type": "REVOLVING",
      "account_type": "SECURED_CREDIT_CARD",
      "interest_type": "VARIABLE",
      "terms_frequency": "MONTHLY"
    }
  }
});

var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("https://sandbox.bloom.dev/v2/furnishment/credit-products/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
```

{% endtab %}

{% tab title="Python - Request" %}

```python
import requests
import json

url = "https://sandbox.bloom.dev/v2/furnishment/credit-products/"

payload = json.dumps({
  "data": {
    "type": "CreditProductCreateRequest",
    "attributes": {
      "name": "Example Credit Card",
      "industry": "CREDIT_CARD_ISSUER",
      "portfolio_type": "REVOLVING",
      "account_type": "SECURED_CREDIT_CARD",
      "interest_type": "VARIABLE",
      "terms_frequency": "MONTHLY"
    }
  }
})
headers = {
  'Authorization': 'Bearer <ACCESS_TOKEN_WILL_BE_HERE>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

```

{% endtab %}

{% tab title="Node.js" %}

```
var request = require('request');
var options = {
  'method': 'POST',
  'url': 'https://sandbox.bloom.dev/v2/furnishment/credit-products/',
  'headers': {
    'Authorization': 'Bearer <ACCESS_TOKEN_WILL_BE_HERE>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "data": {
      "type": "CreditProductCreateRequest",
      "attributes": {
        "name": "Example Credit Card",
        "industry": "CREDIT_CARD_ISSUER",
        "portfolio_type": "REVOLVING",
        "account_type": "SECURED_CREDIT_CARD",
        "interest_type": "VARIABLE",
        "terms_frequency": "MONTHLY"
      }
    }
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

```

{% endtab %}

{% tab title="Go" %}

```go
package main

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

func main() {

  url := "https://sandbox.bloom.dev/v2/furnishment/credit-products/"
  method := "POST"

  payload := strings.NewReader(`{
    "data": {
        "type": "CreditProductCreateRequest",
        "attributes": {
            "name": "Example Credit Card",
            "industry": "CREDIT_CARD_ISSUER",
            "portfolio_type": "REVOLVING",
            "account_type": "SECURED_CREDIT_CARD",
            "interest_type": "VARIABLE",
            "terms_frequency": "MONTHLY"
        }
    }
}
`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "Bearer <ACCESS_TOKEN_WILL_BE_HERE>")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

{% endtab %}
{% endtabs %}

### Credit Product Creation Example Response

You can see an example of a response to a Credit Product creation request below:

{% code title="JSON" %}

```json
{
    "data": {
        "id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
        "type": "CreditProductAPIResponse",
        "attributes": {
            "name": "Example Credit Card",
            "industry": "CREDIT_CARD_ISSUER",
            "portfolio_type": "REVOLVING",
            "account_type": "SECURED_CREDIT_CARD",
            "interest_type": "VARIABLE",
            "terms_frequency": "MONTHLY",
            "id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
            "organization_id": "<ORGANIZATION_ID_WILL_BE_HERE>",
            "created_at": "2023-01-30T20:10:07.828600",
            "modified_at": "2023-01-30T20:10:07.828600"
        }
    }
}
```

{% endcode %}

***

## Account

When an organization signs a customer to one of its products, the outcome is the creation of a related account(s). An account is an instance of a credit product and its relation to one or more consumers. With the Furnishment API, you can create, update, retrieve, and delete accounts.

One consumer can hold multiple accounts. Suppose a consumer has multiple accounts with the same product, such as a home loan with the same bank. In that case, all the accounts will have the same Consumer name but a unique account ID that provides consumer loan details, EMI payment history, and principal amount balance details.

### Create an Account

{% hint style="warning" %}
**Important:**

You must create a credit product and a consumer before creating an account.
{% endhint %}

Once you create a credit product, you can start creating accounts. The account details include the following:

* Credit Product ID
* Primary Consumer ID
* Primary Address ID
* Primary Designation
* Branch Identifier
* Account Opened Date
* Terms Duration
* External Account Identifier

{% hint style="warning" %}
**Business Accounts**

If you select a business credit product for your account, you must enter the attributes `business_name` and `business_address`.
{% endhint %}

Check out the [Create Account](/reference/v2.1/furnishment-api/accounts/create-account.md) API reference to learn how to send a `POST` request to the Furnishment API with the account's information in the request body.

The response will include an ID (`account_id`) that is used to identify the account uniquely.

### Account Creation Example Request

You can see an example of a `POST` request made to the **Create Account** endpoint below:

{% tabs %}
{% tab title="cURL" %}

```bash
curl --location --request POST 'https://sandbox.bloom.dev/v2/furnishment/accounts/' \
--header 'Authorization: Bearer <ACCESS_TOKEN_WILL_BE_HERE>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "data": {
        "type": "AccountCreate",
        "attributes": {
            "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
            "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
            "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
            "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
            "primary_designation": "INDIVIDUAL",
            "branch_identifier": "ABCDEF",
            "account_opened_date": "2006-01-20",
            "terms_duration": "012"
        }
    }
}'
```

{% endtab %}

{% tab title="HTTP" %}

```http
POST /v2/furnishment/accounts/ HTTP/1.1
Host: sandbox.bloom.dev
Authorization: Bearer <ACCESS_TOKEN_WILL_BE_HERE>
Content-Type: application/json
Content-Length: 599

{
    "data": {
        "type": "AccountCreate",
        "attributes": {
            "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
            "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
            "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
            "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
            "primary_designation": "INDIVIDUAL",
            "branch_identifier": "ABCDEF",
            "account_opened_date": "2006-01-20",
            "terms_duration": "012"
        }
    }
}

```

{% endtab %}

{% tab title="JavaScript - Fetch" %}

```javascript
var myHeaders = new Headers();
myHeaders.append("Authorization", "Bearer <ACCESS_TOKEN_WILL_BE_HERE>");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
  "data": {
    "type": "AccountCreate",
    "attributes": {
      "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
      "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
      "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
      "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
      "primary_designation": "INDIVIDUAL",
      "branch_identifier": "ABCDEF",
      "account_opened_date": "2006-01-20",
      "terms_duration": "012"
    }
  }
});

var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("https://sandbox.bloom.dev/v2/furnishment/accounts/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
```

{% endtab %}

{% tab title="Python - Request" %}

```python
import requests
import json

url = "https://sandbox.bloom.dev/v2/furnishment/accounts/"

payload = json.dumps({
  "data": {
    "type": "AccountCreate",
    "attributes": {
      "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
      "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
      "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
      "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
      "primary_designation": "INDIVIDUAL",
      "branch_identifier": "ABCDEF",
      "account_opened_date": "2006-01-20",
      "terms_duration": "012"
    }
  }
})
headers = {
  'Authorization': 'Bearer <ACCESS_TOKEN_WILL_BE_HERE>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

```

{% endtab %}

{% tab title="Node.js" %}

```
var request = require('request');
var options = {
  'method': 'POST',
  'url': 'https://sandbox.bloom.dev/v2/furnishment/accounts/',
  'headers': {
    'Authorization': 'Bearer <ACCESS_TOKEN_WILL_BE_HERE>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "data": {
      "type": "AccountCreate",
      "attributes": {
        "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
        "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
        "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
        "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
        "primary_designation": "INDIVIDUAL",
        "branch_identifier": "ABCDEF",
        "account_opened_date": "2006-01-20",
        "terms_duration": "012"
      }
    }
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

```

{% endtab %}

{% tab title="Go" %}

```go
package main

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

func main() {

  url := "https://sandbox.bloom.dev/v2/furnishment/accounts/"
  method := "POST"

  payload := strings.NewReader(`{
    "data": {
        "type": "AccountCreate",
        "attributes": {
            "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
            "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
            "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
            "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
            "primary_designation": "INDIVIDUAL",
            "branch_identifier": "ABCDEF",
            "account_opened_date": "2006-01-20",
            "terms_duration": "012"
        }
    }
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "Bearer <ACCESS_TOKEN_WILL_BE_HERE>")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

{% endtab %}
{% endtabs %}

### Account Creation Example Response

You can see an example of a response to an account creation request below:

{% code title="JSON" %}

```json
{
    "data": {
        "id": "<ACCOUNT_ID_WILL_BE_HERE>",
        "type": "Account",
        "attributes": {
            "credit_product_id": "<CREDIT_PRODUCT_ID_WILL_BE_HERE>",
            "account_opened_date": "2006-01-20",
            "primary_consumer_id": "<PRIMARY_CONSUMER_ID_WILL_BE_HERE>",
            "primary_address_id": "<PRIMARY_ADDRESS_ID_WILL_BE_HERE>",
            "primary_designation": "INDIVIDUAL",
            "paid_off": false,
            "terms_duration": "012",
            "id": "<ACCOUNT_ID_WILL_BE_HERE>",
            "external_account_identifier": "<EXTERNAL_ACCOUNT_IDENTIFIER_WILL_BE_HERE>",
            "reported_consumer_account_number": "<REPORTED_CONSUMER_ACCOUNT_NUMBER_WILL_BE_HERE>",
            "secondary_consumers": [],
            "credit_line_suspended": false,
            "organization_id": "<ORGANIZATION_ID_WILL_BE_HERE>",
            "charge_off": {},
            "collateral": {},
            "collections": {},
            "lien": {},
            "positions": {},
            "payment_default": {},
            "forbearance": {}
        }
    }
}
```

{% endcode %}

***

## Statement

A statement indicates the summary of an account. They can be granted for almost every account representing ongoing transactions where funds are repeatedly exchanged.

Statements typically list debits paid, incoming funds or credits received by the account holder, and fees associated with maintaining the account.

With the Furnishment API, you can submit and retrieve statements.

### Submit a Statement

Once you create an account, you can start furnishing statements. The statement includes the following:

* Customer details
* Account details
* Payment details

Check out the [Create Statement](/reference/v2.1/furnishment-api/statements/create-statement.md) API reference to learn how to send a `POST` request to the Furnishment API with the statement's information in the request body.

The response will include an ID (`statement_id`) that is used to identify the statement uniquely.

### Statement Creation Example Request

You can see an example of a `POST` request made to the **Create Statement** endpoint below:

{% tabs %}
{% tab title="cURL" %}

```bash
curl --location --request POST 'https://sandbox.bloom.dev/v2/furnishment/statements/' \
--header 'Authorization: Bearer <ACCESS_TOKEN_WILL_BE_HERE>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "data": {
        "type": "StatementCreate",
        "attributes": {
            "id": "null",
            "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
            "statement_date": "2023-01-29",
            "current_balance": 0.00,
            "days_delinquent": 0,
            "credit_limit": 252.0,
            "scheduled_monthly_payment": 21.0,
            "actual_monthly_payment": 0.00,
            "amount_past_due": 0.00,
            "statement_identifier": "123456789-123456789-123456789",
            "last_payment_date": "2022-04-22"
        }
    }
}'
```

{% endtab %}

{% tab title="HTTP" %}

```http
POST /v2/furnishment/statements/ HTTP/1.1
Host: sandbox.bloom.dev
Authorization: Bearer <ACCESS_TOKEN_WILL_BE_HERE>
Content-Type: application/json
Content-Length: 541

{
    "data": {
        "type": "StatementCreate",
        "attributes": {
            "id": "null",
            "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
            "statement_date": "2023-01-29",
            "current_balance": 0.00,
            "days_delinquent": 0,
            "credit_limit": 252.0,
            "scheduled_monthly_payment": 21.0,
            "actual_monthly_payment": 0.00,
            "amount_past_due": 0.00,
            "statement_identifier": "123456789-123456789-123456789",
            "last_payment_date": "2022-04-22"
        }
    }
}
```

{% endtab %}

{% tab title="JavaScript - Fetch" %}

```javascript
var myHeaders = new Headers();
myHeaders.append("Authorization", "Bearer <ACCESS_TOKEN_WILL_BE_HERE>");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
  "data": {
    "type": "StatementCreate",
    "attributes": {
      "id": "null",
      "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
      "statement_date": "2023-01-29",
      "current_balance": 0,
      "days_delinquent": 0,
      "credit_limit": 252,
      "scheduled_monthly_payment": 21,
      "actual_monthly_payment": 0,
      "amount_past_due": 0,
      "statement_identifier": "123456789-123456789-123456789",
      "last_payment_date": "2022-04-22"
    }
  }
});

var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("https://sandbox.bloom.dev/v2/furnishment/statements/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
```

{% endtab %}

{% tab title="Python - Request" %}

```python
import requests
import json

url = "https://sandbox.bloom.dev/v2/furnishment/statements/"

payload = json.dumps({
  "data": {
    "type": "StatementCreate",
    "attributes": {
      "id": "null",
      "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
      "statement_date": "2023-01-29",
      "current_balance": 0,
      "days_delinquent": 0,
      "credit_limit": 252,
      "scheduled_monthly_payment": 21,
      "actual_monthly_payment": 0,
      "amount_past_due": 0,
      "statement_identifier": "123456789-123456789-123456789",
      "last_payment_date": "2022-04-22"
    }
  }
})
headers = {
  'Authorization': 'Bearer <ACCESS_TOKEN_WILL_BE_HERE>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

```

{% endtab %}

{% tab title="Node.js" %}

```
var request = require('request');
var options = {
  'method': 'POST',
  'url': 'https://sandbox.bloom.dev/v2/furnishment/statements/',
  'headers': {
    'Authorization': 'Bearer <ACCESS_TOKEN_WILL_BE_HERE>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "data": {
      "type": "StatementCreate",
      "attributes": {
        "id": "null",
        "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
        "statement_date": "2023-01-29",
        "current_balance": 0,
        "days_delinquent": 0,
        "credit_limit": 252,
        "scheduled_monthly_payment": 21,
        "actual_monthly_payment": 0,
        "amount_past_due": 0,
        "statement_identifier": "123456789-123456789-123456789",
        "last_payment_date": "2022-04-22"
      }
    }
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

```

{% endtab %}

{% tab title="Go" %}

```go
package main

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

func main() {

  url := "https://sandbox.bloom.dev/v2/furnishment/statements/"
  method := "POST"

  payload := strings.NewReader(`{
    "data": {
        "type": "StatementCreate",
        "attributes": {
            "id": "null",
            "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
            "statement_date": "2023-01-29",
            "current_balance": 0.00,
            "days_delinquent": 0,
            "credit_limit": 252.0,
            "scheduled_monthly_payment": 21.0,
            "actual_monthly_payment": 0.00,
            "amount_past_due": 0.00,
            "statement_identifier": "123456789-123456789-123456789",
            "last_payment_date": "2022-04-22"
        }
    }
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "Bearer <ACCESS_TOKEN_WILL_BE_HERE>")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
**Statement Identifier**

The `statement identifier` attribute is set by you according to your organization's guidelines, and is different from the `statement_id` in the response.
{% endhint %}

### Statement Creation Example Response

You can see an example of a response to a Statement creation request below:

{% code title="JSON" %}

```json
{
    "data": {
        "id": "<STATEMENT_ID_WILL_BE_HERE>",
        "type": "Statement",
        "attributes": {
            "account_id": "<ACCOUNT_ID_WILL_BE_HERE>",
            "statement_date": "2023-01-29",
            "current_balance": 0.0,
            "days_delinquent": 0,
            "credit_limit": 252.0,
            "scheduled_monthly_payment": 21.0,
            "actual_monthly_payment": 0.0,
            "amount_past_due": 0.0,
            "last_payment_date": "2022-04-22",
            "highest_balance": 0.0,
            "statement_identifier": "123456789-123456789-123456789",
            "charge_off": {},
            "collateral": {},
            "collections": {},
            "lien": {},
            "forbearance": {},
            "positions": {},
            "payment_default": {},
            "deleted": {},
            "id": "<STATEMENT_ID_WILL_BE_HERE>",
            "modified_at": "2023-01-30T22:32:58.830855"
        }
    }
}
```

{% endcode %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://developers.bloomcredit.io/docs/v2.1/quick-start/update-furnish-accounts.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.