Dotfile

https://docs.dotfile.com
Admin
Dotfile is an end-to-end business verification platform that orchestrates identity verification, AML...
Tokens:570,400
Snippets:2,068
Trust Score:7.5
Update:10 months ago
Show doc for...
Tokens:
Raw
### Dotfile API - Introduction

Source: https://docs.dotfile.com/reference/getting-started-1

This section provides an overview of the Dotfile API, its core concepts, and how to get started with API key generation and testing.

```APIDOC
## Dotfile API Overview

### Description
Welcome to the Dotfile API documentation. Dotfile is a comprehensive platform for customer verification, offering robust tools for managing KYC/KYB processes.

Key concepts include:
*   **Cases**: Manage your KYC/KYB workflows.
*   **Company Data**: Search and enrich company information, including documents.
*   **Entities**: Add companies or individuals to your cases.
*   **Checks**: Perform various verification processes on entities (e.g., ID verification, AML screening).
*   **Webhooks**: Receive real-time notifications for specific events.

### Getting Started
To begin using the API, generate an API key from your workspace. You can then test the API using the provided reference or tools like Postman or Insomnia.

### API Specification
An OpenAPI v3 JSON specification is available [here](/openapi/%EF%B8%8F-api-specifications.json).
```

--------------------------------

### Migration Guide: document_type to document_type_key

Source: https://docs.dotfile.com/changelog_page=2

This guide explains the change from `data.settings.document_type` to `data.settings.document_type_key` for consistent document type handling. It includes code examples for both before and after the migration.

```APIDOC
## Migration Guide: document_type to document_type_key

Replace `data.settings.document_type` with `data.settings.document_type_key`, which provides consistent behavior for all document types.

**Before:**
```javascript
const { settings } = check.data;

let key; // string
let documentType; // Object or null

if (settings.document_type !== null) {
  // Handle default document type
  key = settings.document_type;
  documentType = null;
}
if (settings.custom_document_type !== null) {
  // Handle custom document type
  key = settings.custom_document_type.key;
  documentType = settings.custom_document_type;
}

// Do something with the key or documentType
```

**After:**
```javascript
const { settings } = check.data;

const key = settings.document_type_key; // String
// Do something with the key

// If you need information on the document type object, also do the following:

let documentType; // Object, always set after the changes take effect

if (settings.document_type) {
  if (typeof settings.document_type === "object") {
    // Be ready for the new document_type
    documentType = settings.document_type;
  }

  // Until the change takes effect, document_type can still be a null or a string and in this case it should be ignored

} else if (settings.custom_document_type) {
  // Until the change takes effect, custom_document_type is still set for "custom" document type
  documentType = settings.custom_document_type;
}

// Do something with the documentType
```

**Affected endpoints and webhooks**:
  * Create a Document check (`POST /v1/checks/document`), Add files (`POST /v1/checks/document/{id}/add_files`), Retrieve a Document check (`GET /v1/checks/document/{id}`), Force review (`POST /v1/checks/document/{id}/force_review`), Review a Document check (`PATCH /v1/checks/document/{id}/review`)
  * `DocumentCheckWebhook`
```

--------------------------------

### Get Individuals List (Python)

Source: https://docs.dotfile.com/reference/individuals

Provides a Python example for retrieving a list of individuals from the Dotfile API. It shows how to make a GET request with sorting and pagination query parameters and includes the necessary 'accept' header for a JSON response.

```python
import requests

url = "https://api.dotfile.com/v1/individuals"
params = {
    "sort": "created_at",
    "page": "1",
    "limit": "20"
}
headers = {
    "accept": "application/json"
}

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

print(response.json())
```

--------------------------------

### Get Individuals List (Node.js)

Source: https://docs.dotfile.com/reference/individuals

Fetches a list of individuals using Node.js. This example demonstrates making a GET request to the Dotfile API's individuals endpoint with sorting and pagination parameters. It expects a JSON response.

```javascript
const options = {
  method: 'GET',
  url: 'https://api.dotfile.com/v1/individuals',
  params: {
    sort: 'created_at',
    page: '1',
    limit: '20'
  },
  headers: {
    accept: 'application/json'
  }
};

// Assuming you have a library like axios installed for making HTTP requests
// axios.request(options).then(function (response) {
//   console.log(response.data);
// }).catch(function (error) {
//   console.error(error);
// });
```

--------------------------------

### Ping Dotfile API (Node.js)

Source: https://docs.dotfile.com/reference/ping

This Node.js example shows how to ping the Dotfile API using the 'node-fetch' library to test your API key. It sends a GET request to the /v1/ping endpoint.

```javascript
import fetch from 'node-fetch';

const url = 'https://api.dotfile.com/v1/ping';

fetch(url, {
  method: 'GET',
  headers: {
    'accept': 'application/json'
  }
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));
```

--------------------------------

### Ping Dotfile API (Ruby)

Source: https://docs.dotfile.com/reference/ping

This Ruby example demonstrates how to ping the Dotfile API using the built-in 'Net::HTTP' library to test your API key. It sends a GET request to the /v1/ping endpoint.

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

uri = URI.parse('https://api.dotfile.com/v1/ping')

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  request = Net::HTTP::Get.new(uri)
  request['accept'] = 'application/json'
  http.request(request)
end

puts response.body
```

--------------------------------

### Ping Dotfile API (Python)

Source: https://docs.dotfile.com/reference/ping

This Python example demonstrates how to ping the Dotfile API using the 'requests' library to test your API key. It sends a GET request to the /v1/ping endpoint.

```python
import requests

url = 'https://api.dotfile.com/v1/ping'
headers = {
    'accept': 'application/json'
}

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

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")
```

--------------------------------

### Get Individuals List (PHP)

Source: https://docs.dotfile.com/reference/individuals

Demonstrates fetching a list of individuals via the Dotfile API using PHP. This code prepares a GET request with sorting and pagination parameters and specifies the expected JSON response format.

```php
$curl = curl_init();

curl_setopt($curl, CURLOPT_URL, "https://api.dotfile.com/v1/individuals?sort=created_at&page=1&limit=20");
curl_setopt($curl, CURLOPT_HTTPHEADER, [
  'accept: application/json',
]);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($curl);

if (curl_errno($curl)) {
    echo 'Error:' . curl_error($curl);
}

curl_close($curl);

echo $response;
```

--------------------------------

### Create Note API Request Examples (cURL, Shell, Node, Ruby, PHP, Python)

Source: https://docs.dotfile.com/reference/notes

Examples of how to create a note using the Dotfile API. This includes cURL requests and examples in various programming languages. The request requires a POST method to the specified URL with JSON content type, including case ID and note content. Responses indicate success or specific error conditions.

```shell
curl --request POST \
     --url https://api.dotfile.com/v1/notes \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --data '{ "case_id": "your_case_id", "content": "This is a note with <b>html</b> content." }'
```

```node
const options = {
  method: 'POST',
  url: 'https://api.dotfile.com/v1/notes',
  headers: {
    'accept': 'application/json',
    'content-type': 'application/json'
  },
  body: {
    case_id: 'your_case_id',
    content: 'This is a note with <b>html</b> content.'
  }
};

fetch(options.url, options)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));
```

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

url = URI("https://api.dotfile.com/v1/notes")

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

request = Net::HTTP::Post.new(url)
request["accept"] = "application/json"
request["content-type"] = "application/json"
request.body = JSON.dump({"case_id": "your_case_id", "content": "This is a note with <b>html</b> content."})

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

```php
<?php

$curl = curl_init();

curl_setopt($curl, CURLOPT_URL, 'https://api.dotfile.com/v1/notes');
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_HTTPHEADER, [
  'Accept: application/json',
  'Content-Type: application/json'
]);

$data = [
    'case_id' => 'your_case_id',
    'content' => 'This is a note with <b>html</b> content.'
];
curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($curl);

if (curl_errno($curl)) {
    echo 'Error:' . curl_error($curl);
}

curl_close($curl);

echo $response;

?>
```

```python
import requests

url = "https://api.dotfile.com/v1/notes"

payload = {
    "case_id": "your_case_id",
    "content": "This is a note with <b>html</b> content."
}
headers = {
  'accept': 'application/json',
  'content-type': 'application/json'
}

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

print(response.text)
```

--------------------------------

### Custom Property Example Payload

Source: https://docs.dotfile.com/reference/individual-set-relevant

Provides an example JSON object demonstrating the structure and typical values for various custom properties, including text, boolean, date, arrays of countries and choices, numeric values, and null properties.

```json
{
  "custom_text": "Custom properties text",
  "custom_boolean": true,
  "custom_date": "2012-12-12",
  "custom_countries": [
    "FR"
  ],
  "custom_choices": [
    "option1",
    "option2"
  ],
  "custom_numeric": 12.3,
  "custom_property": null
}
```

--------------------------------

### GET /websites/dotfile

Source: https://docs.dotfile.com/reference/case-get-many-notes

Retrieves case notes and comments for a given case.

```APIDOC
## GET /websites/dotfile

### Description
Returns case's notes with comments.

### Method
GET

### Endpoint
/websites/dotfile

### Parameters
#### Query Parameters
- **case_id** (string) - Required - The ID of the case to retrieve notes for.

### Request Example
```json
{
  "example": "This is a placeholder for a GET request example. No request body is typically needed for a GET request."
}
```

### Response
#### Success Response (200)
- **notes** (array) - A list of case notes.
  - **note_id** (string) - The ID of the note.
  - **content** (string) - The content of the note.
  - **comments** (array) - A list of comments associated with the note.
    - **comment_id** (string) - The ID of the comment.
    - **author** (string) - The author of the comment.
    - **text** (string) - The text of the comment.

#### Response Example
```json
{
  "notes": [
    {
      "note_id": "note123",
      "content": "This is the first note.",
      "comments": [
        {
          "comment_id": "comment456",
          "author": "John Doe",
          "text": "Great note!"
        }
      ]
    }
  ]
}
```
```

--------------------------------

### Document Template Syntax Example (Carbone.io)

Source: https://docs.dotfile.com/docs/electronic-signature

This example demonstrates the syntax for creating a document template using Carbone.io. It shows how to include dynamic data from case and individual properties, format dates, and specify the signature tag's position and dimensions. The `{{s1|signature|width|height}}` tag is crucial for placing the signature.

```template
POWER OF ATTORNEY

I, the undersigned,
{d.signer_individual.first_name} {d.signer_individual.last_name}
Born on {d.signer_individual.birth_date:formatD(LL)}
At {d.signer_individual.birth_place}, {d.signer_individual.birth_country}

Residing at:
{d.signer_individual.address.street_address}
{d.signer_individual.address.postal_code} {d.signer_individual.address.city}
{d.signer_individual.address.country}

Acting in my capacity as {d.signer_individual.position} of:
{d.main_company.name}
Registered under number {d.main_company.registration_number}
With registered office at:
{d.main_company.address.street_address}
{d.main_company.address.postal_code} {d.main_company.address.city}
{d.main_company.address.country}

HEREBY GRANT POWER OF ATTORNEY TO:

{d.individuals[is_signatory=true].first_name} {d.individuals[is_signatory=true].last_name}

To represent me and act on my behalf in all matters relating to:
[Scope of authority to be specified]

This power of attorney shall remain valid until [specify end date or condition].

The attorney-in-fact shall have full power and authority to act on my behalf in the same manner and with the same force and effect as if I had taken such action myself with respect to the powers specified above.


The Delegator:

{d.individuals[is_delegator=true].first_name} {d.individuals[is_delegator=true].last_name}

Date: {c.now:formatD('LL')}

{{s1|signature|85|37}}
```

--------------------------------

### API Key Generation

Source: https://docs.dotfile.com/reference

Instructions on how to generate an API key to start using the Dotfile API.

```APIDOC
## API Key Generation

### Description
To begin interacting with the Dotfile API, you need to generate an API key from your workspace. This key will be used for authentication when making API requests.

### How to Generate
1. Navigate to your workspace settings.
2. Locate the API key section.
3. Generate a new API key.

Once generated, you can use this key to test the API via the API reference documentation or in your preferred API client (e.g., Postman, Insomnia).
```

--------------------------------

### GET /v1/checks/id_document/{id}

Source: https://docs.dotfile.com/reference/id-document-get-one

Retrieves detailed information about a specific ID Document check. You can find more information about ID document checks and files in the related guides.

```APIDOC
## GET /v1/checks/id_document/{id}

### Description
Returns detailed information about the specified ID Document check. This endpoint is useful for fetching the status and results of an ID document verification process.

---

#### See also  
Learn more about [Id document checks](./id-document-checks-guide)  
Learn more about [Files](./files-guide)  

### Method
GET

### Endpoint
/v1/checks/id_document/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - Id of the ID Document check (uuid format)

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the check (uuid format).
- **individual_id** (string) - Identifier for the individual associated with the check (uuid format).
- **is_internal** (boolean) - Flag indicating if the check is internal.
- **status** (string) - The current status of the check. Possible values: `in_progress`, `need_review`, `processing`, `approved`, `rejected`, `expired`.
- **type** (string) - The type of the check, always `id_document`.
- **subtype** (string | null) - Currently always null for `id_document` Check.
- **last_activity_at** (string) - The date and time of the latest activity in ISO 8601 format.
- **data** (object) - Contains detailed data about the ID document check.
    - **result** (string | null) - The final result of the check. Possible values: `approved`, `rejected`, `error`.
    - **settings** (object) - Configuration settings for the check.
        - **vendor** (string) - The vendor used for the check. Possible values: `veriff`, `idnow`.
        - **automatic_approval** (boolean) - Whether automatic approval is enabled.
        - **automatic_rejection** (boolean) - Whether automatic rejection is enabled.
    - **vendor** (object) - Information about the vendor that performed the check.
        - **name** (string) - The name of the vendor. Possible values: `veriff`, `idnow`.
        - **verification_ref** (string | null) - Vendor's reference for the verification.
        - **verification_group_ref** (string | null) - Vendor's reference for the verification group.
        - **verification_status** (string) - The status reported by the vendor.

#### Response Example
```json
{
  "id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "individual_id": "f0e9d8c7-b6a5-4321-fedc-ba9876543210",
  "is_internal": false,
  "status": "approved",
  "type": "id_document",
  "subtype": null,
  "last_activity_at": "2023-10-27T10:30:00.000Z",
  "data": {
    "result": "approved",
    "settings": {
      "vendor": "veriff",
      "automatic_approval": true,
      "automatic_rejection": false
    },
    "vendor": {
      "name": "veriff",
      "verification_ref": "vrf_12345",
      "verification_group_ref": "vrg_67890",
      "verification_status": "completed"
    }
  }
}
```
```

--------------------------------

### Create a Case with Custom Properties (JSON)

Source: https://docs.dotfile.com/reference/cases

Example demonstrating how to create a case with custom properties. The `custom_properties` object allows for key-value pairs, where keys correspond to predefined custom property configurations and values adhere to their respective types (e.g., boolean, array of strings).

```json
{
  "name": "Some example case",
  "status": "open",
  "custom_properties": {
    "ubo_us_citizen": true,
    "main_activity_country": ["FR"]
  }
}
```

--------------------------------

### Ping Dotfile API (PHP)

Source: https://docs.dotfile.com/reference/ping

This PHP example shows how to ping the Dotfile API using cURL to test your API key. It sends a GET request to the /v1/ping endpoint.

```php
<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dotfile.com/v1/ping');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

$headers = array();
$headers[] = 'Accept: application/json';
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}

cL_close($ch);

echo $response;
?>
```

--------------------------------

### Metadata Storage Example (JSON)

Source: https://docs.dotfile.com/reference/cases

Demonstrates how to store arbitrary key-value data in the 'metadata' property. Values must be strings, and the entire object is replaced on update. Setting 'metadata' to null removes all existing metadata.

```JSON
{
  "metadata": {
    "custom_key": "true",
    "my_data": "this is important",
    "count": "42"
  }
}
```

--------------------------------

### Test Workflows (Description)

Source: https://docs.dotfile.com/docs/workflows

This section describes how to test workflows using existing cases. It clarifies that these tests simulate execution without performing any actual actions, allowing users to review the intended outcomes based on defined rules.

--------------------------------

### POST /websites/dotfile/{$request.body#/url}

Source: https://docs.dotfile.com/openapi/%EF%B8%8F-api-specifications

This endpoint is called when an individual is created. It accepts an IndividualWebhook payload.

```APIDOC
## POST /websites/dotfile/{$request.body#/url}

### Description
This endpoint is triggered when a new individual is created. It receives webhook notifications for the `Individual.Created` event and expects an IndividualWebhook payload.

### Method
POST

### Endpoint
/websites/dotfile/{$request.body#/url}

### Parameters
#### Request Body
- **url** (string) - Required - The URL to send the webhook notification to.

### Request Example
```json
{
  "url": "https://your-callback-url.com/webhook"
}
```

### Response
#### Success Response (200)
- **description** (string) - A confirmation message indicating the webhook was accepted.

#### Response Example
```json
{
  "description": "Your server returns this code if it accepts the callback"
}
```
```

--------------------------------

### Ping Dotfile API (cURL)

Source: https://docs.dotfile.com/reference/ping

This example demonstrates how to ping the Dotfile API using cURL to test your API key. It sends a GET request to the /v1/ping endpoint with an accept header.

```shell
curl --request GET \
     --url https://api.dotfile.com/v1/ping \
     --header 'accept: application/json'
```

--------------------------------

### Retrieve Company Monitoring Check (Ruby)

Source: https://docs.dotfile.com/reference/company-monitoring-check

Ruby example for making a GET request to retrieve Company Monitoring check information. This code uses the 'net/http' library to interact with the API.

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

id = 'your_company_monitoring_check_id'
uri = URI.parse("https://api.dotfile.com/v1/checks/company-monitoring/#{id}")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  request = Net::HTTP::Get.new(uri)
  request['accept'] = 'application/json'
  http.request(request)
end

puts response.body
```

--------------------------------

### Real-Life Workflow Example with Conditional Logic (JavaScript)

Source: https://docs.dotfile.com/docs/workflows

This comprehensive example demonstrates isolating the main company, applying tags and templates based on country risk, and creating document checks conditionally. It also processes individuals, creating document checks or ID document checks based on their roles.

```javascript
// Isolate the main company
const mainCo = $.input.companies.find((x) => x.type === "main");

const individuals = $.input.individuals;

// Use some custom mappings
const highRiskCountries = ["IR", "PK"];
const HIGH_RISK_TEMPLATE = "c84cc555-8601-450e-ad68-5f611b4b8bb3"

if (mainCo) {

  if (highRiskCountries.includes(mainCo.country)) {
    $.add_tag("HIGH_RISK"),
    $.set_template(HIGH_RISK_TEMPLATE);
  }

  if (mainCo.country === "FR") {
    $.create_document_check({
      company_id: mainCo.id,
      settings: { document_type: "registration_certificate" },
    });
  } else {
    $.create_document_check({
      company_id: mainCo.id,
      settings: {
        document_type_key: "ddbb3049-b0be-4f7e-b493-525ba09aa950",
      },
    });
  }
}

individuals.forEach((individual) => {
  if (
    individual.is_business_contact === true &&
    !individual.is_delegator
  ) {
    $.create_document_check({
      individual_id: individual.id,
      settings: {
        document_type_key: "9ff5c066-7446-4045-a453-6d4832bea585",
      },
    });
  }

  if (individual.is_business_contact === false && individual.is_delegator) {
    $.create_id_document_check({
      individual_id: individual.id,
    });
  }
});


```

--------------------------------

### Retrieve Company Monitoring Check (PHP)

Source: https://docs.dotfile.com/reference/company-monitoring-check

PHP snippet for retrieving Company Monitoring check data. This example utilizes cURL functions within PHP to perform the HTTP GET request.

```php
<?php

$id = 'your_company_monitoring_check_id';
$url = "https://api.dotfile.com/v1/checks/company-monitoring/{$id}";

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Accept: application/json'
]);

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
} else {
    echo $response;
}

curl_close($ch);

?>
```

--------------------------------

### Migrate Document Type Handling in JavaScript

Source: https://docs.dotfile.com/changelog/2025-07-28

This snippet demonstrates how to migrate from using `data.settings.document_type` and `data.settings.custom_document_type` to the new `data.settings.document_type_key`. It shows the 'before' and 'after' code structures for accessing document type information.

```javascript
const { settings } = check.data;

let key; // string
let documentType; // Object or null

if (settings.document_type !== null) {
  // Handle default document type
  key = settings.document_type;
  documentType = null;
}
if (settings.custom_document_type !== null) {
  // Handle custom document type
  key = settings.custom_document_type.key;
  documentType = settings.custom_document_type;
}

// Do something with the key or documentType

```

```javascript
const { settings } = check.data;

const key = settings.document_type_key; // String
// Do something with the key

// If you need information on the document type object, also do the following:

let documentType; // Object, always set after the changes take effect

if (settings.document_type) {
  if (typeof settings.document_type === "object") {
    // Be ready for the new document_type
    documentType = settings.document_type;
  }

  // Until the change takes effect, document_type can still be a null or a string and in this case it should be ignored

} else if (settings.custom_document_type) {
  // Until the change takes effect, custom_document_type is still set for "custom" document type
  documentType = settings.custom_document_type;
}

// Do something with the documentType

```

--------------------------------

### Retrieve Company Monitoring Check (Node.js)

Source: https://docs.dotfile.com/reference/company-monitoring-check

Node.js example for fetching Company Monitoring check details. This snippet demonstrates using the 'axios' library to make a GET request to the Dotfile API.

```javascript
const axios = require('axios');

const id = 'your_company_monitoring_check_id';

axios
  .get(`https://api.dotfile.com/v1/checks/company-monitoring/${id}`)
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error('Error fetching company monitoring check:', error);
  });
```

--------------------------------

### POST /websites/dotfile/{$request.body#/url}

Source: https://docs.dotfile.com/openapi/%EF%B8%8F-api-specifications

This endpoint is called when a note is created. It accepts a NoteWebhook payload.

```APIDOC
## POST /websites/dotfile/{$request.body#/url}

### Description
This endpoint is triggered when a new note is created. It receives webhook notifications for the `Note.Created` event and expects a NoteWebhook payload.

### Method
POST

### Endpoint
/websites/dotfile/{$request.body#/url}

### Parameters
#### Request Body
- **url** (string) - Required - The URL to send the webhook notification to.

### Request Example
```json
{
  "url": "https://your-callback-url.com/webhook"
}
```

### Response
#### Success Response (200)
- **description** (string) - A confirmation message indicating the webhook was accepted.

#### Response Example
```json
{
  "description": "Your server returns this code if it accepts the callback"
}
```
```

--------------------------------

### Create an HTML note with formatting using API

Source: https://docs.dotfile.com/openapi/%EF%B8%8F-api-specifications

This code example shows how to create an HTML-formatted note in a case. It supports rich text elements like paragraphs, bold text, lists, and italics. Ensure the HTML is well-formed. A 201 status code confirms creation.

```json
{
  "case_id": "ba883bef-60fd-42d0-a447-7b7c987c3155",
  "content": "<p>This is a <strong>important</strong><br /></p><ul><li>Some bullet point</li><li><i>supporting some format</i></li></ul>"
}
```

--------------------------------

### Removal of List all custom document types

Source: https://docs.dotfile.com/changelog/2025-07-28

The `GET /v1/custom_document_types` endpoint is deprecated and will be removed. Use the `GET /v1/document_types` endpoint instead for retrieving all available document types.

```APIDOC
## Removal of List all custom document types Endpoint

### Description
The `GET /v1/custom_document_types` endpoint is deprecated and will be removed. This endpoint was used to list all custom document types.

### Deprecated Endpoint
- `GET /v1/custom_document_types`

### Migration Guide
Use the `GET /v1/document_types` endpoint instead. This endpoint returns all available document types, regardless of whether they are 'default' or 'custom'.
```

--------------------------------

### GET /websites/dotfile/custom_properties

Source: https://docs.dotfile.com/reference/custom-property-get-custom-properties

Retrieves a paginated list of custom properties for the 'dotfile' entity type. This endpoint is useful for getting an overview of available custom properties without their detailed options.

```APIDOC
## GET /websites/dotfile/custom_properties

### Description
Returns a paginated list of custom properties for a given entity type. Options are not included in this list; use the detail endpoint to retrieve options.

### Method
GET

### Endpoint
/websites/dotfile/custom_properties

### Parameters
#### Query Parameters
- **page** (integer) - Optional - The page number for pagination.
- **limit** (integer) - Optional - The number of items to return per page.

### Response
#### Success Response (200)
- **data** (array) - A list of custom property objects.
  - **id** (string) - The unique identifier for the custom property.
  - **name** (string) - The name of the custom property.
  - **type** (string) - The data type of the custom property (e.g., 'text', 'number', 'boolean').
- **pagination** (object) - Pagination information.
  - **currentPage** (integer) - The current page number.
  - **totalPages** (integer) - The total number of pages available.
  - **totalItems** (integer) - The total number of items across all pages.

#### Response Example
```json
{
  "data": [
    {
      "id": "prop_abc123",
      "name": "Font Size",
      "type": "number"
    },
    {
      "id": "prop_def456",
      "name": "Background Color",
      "type": "text"
    }
  ],
  "pagination": {
    "currentPage": 1,
    "totalPages": 5,
    "totalItems": 50
  }
}
```
```

--------------------------------

### Get Individuals List (Ruby)

Source: https://docs.dotfile.com/reference/individuals

Retrieves a list of individuals using Ruby. This snippet shows how to construct a GET request to the Dotfile API, including query parameters for sorting and pagination, and setting the appropriate request header.

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

url = URI("https://api.dotfile.com/v1/individuals?sort=created_at&page=1&limit=20")

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

request = Net::HTTP::Get.new(url)
request["accept"] = "application/json"

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

--------------------------------

### GET /websites/dotfile

Source: https://docs.dotfile.com/reference/client-portal-get-many

Retrieves a list of client portals in the workspace. Supports filtering, pagination, and sorting.

```APIDOC
## GET /websites/dotfile

### Description
Retrieves a list of client portals in the workspace. This endpoint supports filtering parameters to narrow down the results, pagination to manage the number of items per page, and sorting to order the returned list.

### Method
GET

### Endpoint
/websites/dotfile

### Parameters
#### Query Parameters
- **page** (number) - Optional - The current page number for pagination.
- **limit** (number) - Optional - The number of items to return per page.
- **sort** (string) - Optional - Specifies the field and order for sorting (e.g., `field_name:asc` or `field_name:desc`).
- **filter** (string) - Optional - Allows filtering the results based on specific criteria. Refer to the API documentation for supported filter parameters and operators.

### Request Example
```
GET /websites/dotfile?page=1&limit=20
```

### Response
#### Success Response (200)
- **data** (array) - An array of client portal objects.
  - **id** (string) - The unique identifier for the client portal (UUID format).
  - **name** (string) - The name of the client portal.
  - **status** (string) - The current status of the client portal (`offline` or `online`).
  - **default_language** (string) - The default language set for the client portal (e.g., `en`, `fr`, `it`).
  - **url** (string) - The URL associated with the client portal.
  - **updated_at** (string) - The date and time when the client portal was last updated (ISO 8601 format).
  - **created_at** (string) - The date and time when the client portal was created (ISO 8601 format).
- **pagination** (object) - An object containing pagination details.
  - **page** (number) - The current page number.
  - **limit** (number) - The number of items per page.
  - **count** (number) - The total number of items available.

#### Response Example
```json
{
  "data": [
    {
      "id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
      "name": "Client Portal Alpha",
      "status": "online",
      "default_language": "en",
      "url": "https://example.com/portals/alpha",
      "updated_at": "2023-10-27T10:30:00.000Z",
      "created_at": "2023-10-26T09:00:00.000Z"
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 20,
    "count": 42
  }
}
```

#### Error Response (400)
- **description** (string) - Details about why the request failed, such as malformed parameters, invalid values, or unsupported sorting fields.
```

--------------------------------

### GET /v1/activities

Source: https://docs.dotfile.com/update/changelog/2025-11-03

This endpoint lists all activities.

```APIDOC
## GET /v1/activities

### Description
This endpoint retrieves a list of all activities.

### Method
GET

### Endpoint
/v1/activities

### Response
#### Success Response (200)
- **activities** (array) - List of activities.

```
Tokens:
Raw