# Investor Data Room Readiness Check (`bloom-consulting/investor-data-room-check`) Actor

Score how ready your investor data room is against a 60-item, 8-folder due-diligence checklist. Flags missing mandatory documents and files older than 90 days, and writes the folder index to build the data room from. English and Turkish.

- **URL**: https://apify.com/bloom-consulting/investor-data-room-check.md
- **Developed by:** [Bloom Consulting](https://apify.com/bloom-consulting) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Investor Data Room Readiness Check

Fundraises stall in diligence, not in the pitch. This Actor scores how ready your data room actually is against a **60-item, 8-folder due-diligence checklist**, tells you which mandatory documents are missing, which ones have gone stale, and gives you the folder index to build the room from.

No API keys, no LLM calls, no data sent anywhere. Deterministic scoring: the same status map always produces the same score.

### What it does

- Scores readiness **0-100**, weighted by folder and by how mandatory each item is.
- Expects different items of you depending on **stage**: `pre-seed`, `seed`, `series-a`, `series-b`.
- Turns on conditional items via **flags**: regulated sector, physical product / inventory, grants and incentives used.
- Flags every **missing mandatory** document — the ones that stop a diligence process rather than slow it.
- Flags **stale** documents: anything marked present but dated more than 90 days ago.
- Writes a **folder index** you can create the data room from, folder by folder, with the owner (lawyer, accountant, founder) named per item.

The eight folders: company information, financial statements, projections, customers and contracts, product and technology, team, legal and compliance, prior rounds and cap table.

Score bands: **0-49 do not open the data room yet**, **50-79 partly ready, close mandatory gaps within two weeks**, **80-100 ready to open to investors**.

### What you get

Every run writes these to the run's key-value store:

| File | What it is |
| --- | --- |
| `readiness-card.md` | One-screen summary: score, band, mandatory gaps, what to fix first |
| `report.html` | Full report — every item with status, owner, why an investor asks for it |
| `report.pdf` | The same report, print-ready |
| `checklist.xlsx` | The whole checklist as a working spreadsheet |
| `INDEX.md` | The folder structure to build, ready to paste into your drive |
| `checklist.json` | Reference: every item code, title, requirement, stage and owner |
| `data.json` | Scores, counts, missing and stale item codes as structured data |
| `input.json` | The exact status map the engine used |

The dataset row carries the score, band, mandatory present/total, status counts, the missing and stale item codes and the per-folder completion percentages.

### Input

Tick **Run with sample data** for a full example run before you enter anything. That run also writes `checklist.json`, which lists **every item code** you can set — the fastest way to see the whole checklist.

Then fill **Data room status**. Field names and status values can be English or Turkish.

```json
{
  "company": "Example Technology Inc.",
  "stage": "seed",
  "roundTarget": "Seed - USD 1.5M",
  "flags": {
    "regulated": false,
    "physicalProduct": false,
    "incentive": true
  },
  "statuses": {
    "01-01": {"status": "have",    "date": "2026-03-10", "note": ""},
    "01-05": {"status": "missing", "date": null,         "note": ""},
    "02-01": {"status": "have",    "date": "2026-02-28", "note": "Audited"},
    "02-04": {"status": "partial", "date": "2026-06-30", "note": "Q2 pending"},
    "03-01": {"status": "have",    "date": "2025-11-15", "note": "Needs refresh"}
  }
}
```

Notes:

- **You do not have to list all 60 codes.** Anything you omit counts as missing, so you can start with what you have and add as you go.
- **`status`** is `have`, `partial`, `missing` or `not applicable` (Turkish `var`, `kismen`, `yok`, `uygulanamaz` also work).
- **`date`** is when the document was last updated, `YYYY-MM-DD`. It is what staleness is measured from — leave it `null` if you do not know.
- **`stage`** matters: an item that only becomes expected at Series A is not counted against a pre-seed company.
- **`flags`** switch on conditional items. Set `incentive: true` and grant documentation is added to what you are scored on.
- Instead of the JSON field you can pass **Input file URL** — a public link to a JSON file with the same status map.

### Report language

`language: "en"` or `"tr"`. Every output — readiness card, HTML, PDF, spreadsheet, folder index — is produced in the chosen language.

### Typical uses

- **Founders before a raise** — find out you are missing three mandatory documents now, not in week two of diligence.
- **Founders during a raise** — a weekly re-run showing the score climb as gaps close.
- **Investors and accelerators** — send it to a company and get a comparable readiness read back instead of a folder tour.
- **Lawyers and accountants** — a shared punch list where every item already names its owner.

### Cost

The Actor is free to use; you pay only Apify platform usage for the run. A run takes roughly 15-40 seconds, most of it PDF rendering. Turn **Generate PDF** off for the cheapest possible run.

### Limits and honesty

- It scores **whether a document exists and how fresh it is**, not whether it is any good. A cap table that exists and is wrong scores the same as a correct one.
- The checklist reflects common practice in early-stage venture diligence. A specific investor, a regulated sector or a cross-border round will ask for things it does not list.
- The 90-day staleness rule is a default, not a law. Articles of association do not go stale in a quarter; a pipeline forecast does.
- This is not legal advice. The owner labels (lawyer, accountant, founder) are a workflow aid, nothing more.

### About

Built by **Bloom Consulting**, a fractional CFO practice working with startups and SMEs. The [paid desktop edition](https://bloomconsulting.com.tr/paketler?utm_source=apify\&utm_medium=store\&utm_campaign=kasa\&utm_content=readme-paid#ajanlar) adds folder scanning — point it at your existing data room and it marks items automatically — plus run-over-run progress tracking and branded templates.

- Web: [bloomconsulting.com.tr](https://bloomconsulting.com.tr/?utm_source=apify\&utm_medium=store\&utm_campaign=kasa\&utm_content=readme-footer)
- Contact: iletisim@bloomconsulting.com.tr

Found a bug or want an item added to the checklist? Open an issue on the Actor page.

# Actor input Schema

## `useSampleData` (type: `boolean`):

Ignore the fields below and run on a built-in example company. Use this first to see the report and the full item list. Reports produced this way are stamped DEMO.

## `dataRoom` (type: `object`):

stage: pre-seed | seed | series-a | series-b (it decides which items are expected of you). flags turn conditional items on. statuses maps an item code to have | partial | missing | not applicable, with the document's date so staleness can be checked. You do not need to list every code — anything you omit counts as missing. Run once with sample data to get the full code list in the `checklist.json` record. English and Turkish values are both accepted.

## `inputFileUrl` (type: `string`):

Alternative to the field above: a public http(s) URL of a JSON file holding the same status map. Used only when "Data room status" is empty.

## `companyName` (type: `string`):

Overrides the company name inside the data. Leave empty to keep it.

## `language` (type: `string`):

Language of the readiness card, HTML report, PDF, spreadsheet and folder index.

## `generatePdf` (type: `boolean`):

Print the HTML report to PDF with headless Chromium. Turn off for a faster, cheaper run.

## Actor input object example

```json
{
  "useSampleData": false,
  "dataRoom": {
    "company": "Example Technology Inc.",
    "stage": "seed",
    "roundTarget": "Seed - USD 1.5M",
    "flags": {
      "regulated": false,
      "physicalProduct": false,
      "incentive": true
    },
    "statuses": {
      "01-01": {
        "status": "have",
        "date": "2026-03-10",
        "note": ""
      },
      "01-02": {
        "status": "have",
        "date": "2026-03-10",
        "note": ""
      },
      "01-05": {
        "status": "missing",
        "date": null,
        "note": ""
      },
      "02-01": {
        "status": "have",
        "date": "2026-02-28",
        "note": "Audited"
      },
      "02-04": {
        "status": "partial",
        "date": "2026-06-30",
        "note": "Q2 pending"
      },
      "03-01": {
        "status": "have",
        "date": "2025-11-15",
        "note": "Needs refresh"
      },
      "08-01": {
        "status": "missing",
        "date": null,
        "note": ""
      }
    }
  },
  "language": "en",
  "generatePdf": true
}
```

# Actor output Schema

## `results` (type: `string`):

The readiness check: 0-100 score, band, mandatory items in place, item counts, missing and stale items and the folder-by-folder breakdown.

## `readinessCard` (type: `string`):

One-screen summary: the readiness score, the mandatory-item count and what is missing.

## `reportHtml` (type: `string`):

The full report, section by section, ready to read in the browser.

## `reportPdf` (type: `string`):

The same report, print-ready.

## `checklist` (type: `string`):

All 60 items across the 8 folders with their status, owner and notes.

## `data` (type: `string`):

Every intermediate figure the report was built from - the audit trail.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "dataRoom": {
        "company": "Example Technology Inc.",
        "stage": "seed",
        "roundTarget": "Seed - USD 1.5M",
        "flags": {
            "regulated": false,
            "physicalProduct": false,
            "incentive": true
        },
        "statuses": {
            "01-01": {
                "status": "have",
                "date": "2026-03-10",
                "note": ""
            },
            "01-02": {
                "status": "have",
                "date": "2026-03-10",
                "note": ""
            },
            "01-05": {
                "status": "missing",
                "date": null,
                "note": ""
            },
            "02-01": {
                "status": "have",
                "date": "2026-02-28",
                "note": "Audited"
            },
            "02-04": {
                "status": "partial",
                "date": "2026-06-30",
                "note": "Q2 pending"
            },
            "03-01": {
                "status": "have",
                "date": "2025-11-15",
                "note": "Needs refresh"
            },
            "08-01": {
                "status": "missing",
                "date": null,
                "note": ""
            }
        }
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bloom-consulting/investor-data-room-check").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "dataRoom": {
        "company": "Example Technology Inc.",
        "stage": "seed",
        "roundTarget": "Seed - USD 1.5M",
        "flags": {
            "regulated": False,
            "physicalProduct": False,
            "incentive": True,
        },
        "statuses": {
            "01-01": {
                "status": "have",
                "date": "2026-03-10",
                "note": "",
            },
            "01-02": {
                "status": "have",
                "date": "2026-03-10",
                "note": "",
            },
            "01-05": {
                "status": "missing",
                "date": None,
                "note": "",
            },
            "02-01": {
                "status": "have",
                "date": "2026-02-28",
                "note": "Audited",
            },
            "02-04": {
                "status": "partial",
                "date": "2026-06-30",
                "note": "Q2 pending",
            },
            "03-01": {
                "status": "have",
                "date": "2025-11-15",
                "note": "Needs refresh",
            },
            "08-01": {
                "status": "missing",
                "date": None,
                "note": "",
            },
        },
    } }

# Run the Actor and wait for it to finish
run = client.actor("bloom-consulting/investor-data-room-check").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "dataRoom": {
    "company": "Example Technology Inc.",
    "stage": "seed",
    "roundTarget": "Seed - USD 1.5M",
    "flags": {
      "regulated": false,
      "physicalProduct": false,
      "incentive": true
    },
    "statuses": {
      "01-01": {
        "status": "have",
        "date": "2026-03-10",
        "note": ""
      },
      "01-02": {
        "status": "have",
        "date": "2026-03-10",
        "note": ""
      },
      "01-05": {
        "status": "missing",
        "date": null,
        "note": ""
      },
      "02-01": {
        "status": "have",
        "date": "2026-02-28",
        "note": "Audited"
      },
      "02-04": {
        "status": "partial",
        "date": "2026-06-30",
        "note": "Q2 pending"
      },
      "03-01": {
        "status": "have",
        "date": "2025-11-15",
        "note": "Needs refresh"
      },
      "08-01": {
        "status": "missing",
        "date": null,
        "note": ""
      }
    }
  }
}' |
apify call bloom-consulting/investor-data-room-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bloom-consulting/investor-data-room-check"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/v7OJ3Muze63HnYBwo/builds/qwecldrWyFY1healV/openapi.json
