# Clio App Directory Scraper (`parseforge/clio-app-directory-scraper`) Actor

Scrape 300+ legal-tech integrations from Clio's App Directory: app names, categories, supported Clio products, vendor links and more.

- **URL**: https://apify.com/parseforge/clio-app-directory-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $56.25 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## ⚖️ Clio App Directory Scraper

> 🚀 **Export 300+ legal-tech integrations from Clio's App Directory in seconds.** Pull app names, categories, compatible Clio products, regions, partner tiers, and outbound vendor links. No login, no API key, no manual scraping.

> 🕒 **Last updated:** 2026-05-25 · **📊 11 fields** per record · **300+ apps catalogued** · **24 categories** · **5 supported regions**


<table><tr>
<td style="border-left:4px solid #0F766E;padding:12px 16px;font-weight:600">Pull structured records from Clio App Directory — clean fields ready as CSV, JSON, JSONL, Excel, or XML for downstream pipelines.</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

parseforge/clio-app-directory-scraper on Apify. Call: ApifyClient("TOKEN").actor("parseforge/clio-app-directory-scraper").call(run\_input={...}), then client.dataset(run\["defaultDatasetId"]).list\_items().items for results. Key inputs: maxItems (integer, default 10), categorySlug (string, default ""), regionSlug (string, default ""). Full actor spec: fetch build via GET https://api.apify.com/v2/acts/parseforge~clio-app-directory-scraper (Bearer TOKEN). Get token: https://console.apify.com/account/integrations

````

Clio is the world's leading cloud-based legal practice management platform, used by **150,000+ legal professionals across 130+ countries**. Its App Directory is the canonical catalogue of every third-party tool that integrates with **Clio Manage, Clio Grow, Clio Personal Injury, Clio Payments, and Clio Duo**. For legal-tech market researchers and partnership teams, that catalogue is the single best snapshot of the modern law-firm software stack.

This scraper turns the directory into a clean, dated dataset. Every record captures the app's name, logo, listing URL, partner tier (UNICORN, GOLD, SILVER, etc.), tagline, full vendor description, supported Clio products, served regions, and an outbound integration URL. Filter by **category** (24 options from "AI and Automation" to "Time Tracking") or **region** (United States, Canada, United Kingdom, Australia, Europe, Global). Output flows into CSV, Excel, JSON, XML, RSS, or HTML in one click, ready for spreadsheets, BI tools, or downstream automations.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Legal-tech founders and product teams | Map the integration landscape before launching a Clio-compatible app |
| Partnership and BD leads at SaaS vendors | Find white-space categories and identify co-marketing opportunities |
| Investors and analysts covering legal tech | Track ecosystem growth, partner-tier mix, and category density |
| Law-firm IT and operations leads | Discover apps that plug into the Clio products their firm already uses |
| Marketing and content teams | Build comparison articles, integration directories, or category roundups |
| Data journalists and researchers | Quantify the modern law-firm software stack and write it up |

---

### 📋 What the Clio App Directory Scraper does

- 📦 **Catalogue every public integration.** Walks the full `/app-directory/` listing, paging through up to **38 pages of results**.
- 🏷️ **Capture rich taxonomy.** Pulls all category chips, partner-tier badges (UNICORN / GOLD / SILVER / BRONZE / CERTIFIED), and supported Clio products per app.
- 🌍 **Track regional availability.** Lists every country or region the integration is officially available in.
- 🧾 **Extract vendor copy.** Saves the canonical app tagline plus the full "How it works with Clio" description (1.5-4 KB of structured prose per app).
- 🔗 **Resolve the outbound vendor URL.** Returns the "Get Started" partner link straight from the app's Clio listing, so downstream automations can follow it without HTML parsing.
- 💾 **Stable, dated snapshots.** Every record carries an ISO `scrapedAt` timestamp so you can run the actor on a schedule and diff month-over-month.

Each record is a flat JSON object with **11 fields**, ordered for spreadsheet readability: logo first, then the app name, listing URL, partner tier, tagline, categories, compatibility, regions, vendor URL, scrape timestamp, and error column (always last). No nested objects, no AI fluff, no invented fields.

> 💡 **Why it matters:** the App Directory is the closest thing to a public, structured map of the legal-tech ecosystem. Whether you sell into law firms, fund the category, or build apps for it, that map is the difference between guessing and knowing.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough of input setup, sample output, and downstream pipeline tips.

---

### ⚙️ Input

<table>
<thead>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Default</th><th>Description</th></tr>
</thead>
<tbody>
<tr>
<td>maxItems</td>
<td>integer</td>
<td>No</td>
<td>10</td>
<td>How many apps to collect. Free plan caps at 10; paid plans go up to 1,000,000.</td>
</tr>
<tr>
<td>categorySlug</td>
<td>string (enum)</td>
<td>No</td>
<td>All categories</td>
<td>Restrict to a single category slug (e.g. time-tracking, document-automation, accounting). 24 options.</td>
</tr>
<tr>
<td>regionSlug</td>
<td>string (enum)</td>
<td>No</td>
<td>All regions</td>
<td>Restrict to a single region slug (united-states, canada, united-kingdom, australia, europe, global).</td>
</tr>
</tbody>
</table>

Example: pull the first 25 apps across all categories.

```json
{
  "maxItems": 25
}
````

Example: pull the first 50 time-tracking apps available in the United States.

```json
{
  "maxItems": 50,
  "categorySlug": "time-tracking",
  "regionSlug": "united-states"
}
```

> ⚠️ **Good to Know:** Clio sits behind Cloudflare's interactive challenge, so the actor uses a residential proxy and a stealth browser. The first record on a new run typically takes 10-15 seconds while the challenge clears; subsequent records run in 4-6 seconds each.

***

### 📊 Output

Each app produces a single flat record. Sample below taken from a real run on 2026-05-25.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼 `imageUrl` | string | `https://www.clio.com/wp-content/uploads/2025/06/Copy-of-Scorpion_Lockup-Black.png` |
| 📌 `title` | string | `Scorpion RevenueMAX` |
| 🔗 `url` | string | `https://www.clio.com/app-directory/scorpion-revenuemax/` |
| 🆔 `slug` | string | `scorpion-revenuemax` |
| 🏅 `partnerTier` | string or null | `UNICORN` |
| 💬 `tagline` | string | `Digital marketing that brings you revenue, not just leads...` |
| 📝 `description` | string | 1-4 KB of structured prose covering benefits, how it works with Clio, support links. |
| 🏷 `categories` | string\[] | `["INTAKE", "MARKETING"]` |
| 🔌 `compatibility` | string\[] | `["CLIO GROW", "CLIO MANAGE"]` |
| 🌍 `regions` | string\[] | `["CANADA", "UNITED STATES"]` |
| 🌐 `integrationUrl` | string | `https://www.scorpion.co/clio-app` |
| 🕒 `scrapedAt` | string (ISO) | `2026-05-25T12:54:59.628Z` |
| ❌ `error` | string or null | `null` |

#### 📦 Sample records

<details>
<summary><strong>Typical: premium "UNICORN" partner with multi-product compatibility</strong></summary>

```json
{
  "imageUrl": "https://www.clio.com/wp-content/uploads/2025/06/Copy-of-Scorpion_Lockup-Black.png",
  "title": "Scorpion RevenueMAX",
  "url": "https://www.clio.com/app-directory/scorpion-revenuemax/",
  "slug": "scorpion-revenuemax",
  "partnerTier": "UNICORN",
  "tagline": "Digital marketing that brings you revenue, not just leads, with Clio's preferred marketing services partner.",
  "description": "Key benefits for your firm\nClear Return on Investment\nFirms can now see exactly which marketing efforts turn into real clients...",
  "categories": ["INTAKE", "MARKETING"],
  "compatibility": ["CLIO GROW", "CLIO MANAGE"],
  "regions": ["CANADA", "UNITED STATES"],
  "integrationUrl": "https://www.scorpion.co/clio-app",
  "scrapedAt": "2026-05-25T12:54:59.628Z",
  "error": null
}
```

</details>

<details>
<summary><strong>Edge case: globally-available compliance tool, no partner tier</strong></summary>

```json
{
  "imageUrl": "https://www.clio.com/wp-content/uploads/2025/05/Legl-Logo-Glossy-Dark.png",
  "title": "Legl",
  "url": "https://www.clio.com/app-directory/legl/",
  "slug": "legl",
  "partnerTier": null,
  "tagline": "KYC and AML compliance, and client onboarding",
  "description": "Key benefits for your firm\nAutomate onboarding, KYC, and AML\nOnboard clients faster, reduce risk and give clients a better experience...",
  "categories": ["INTAKE", "AI AND AUTOMATION"],
  "compatibility": ["CLIO MANAGE"],
  "regions": ["AUSTRALIA", "EUROPE", "NEW ZEALAND"],
  "integrationUrl": "https://www.legl.com/integration/clio?utm_campaign=14033510-UKFY25FYPM%20%7C%20Clio%20partnership&utm_source=Clio&utm_medium=Partner",
  "scrapedAt": "2026-05-25T12:55:20.026Z",
  "error": null
}
```

</details>

<details>
<summary><strong>Sparse: single-region, single-product app with minimal taxonomy</strong></summary>

```json
{
  "imageUrl": "https://www.clio.com/wp-content/uploads/2018/02/cs_icon.png",
  "title": "Case Status",
  "url": "https://www.clio.com/app-directory/case-status/",
  "slug": "case-status",
  "partnerTier": null,
  "tagline": "Mobile Client Portal & Communication Platform for Law Firms",
  "description": "Key benefits for your firm\nGive Your Clients a Seamless Mobile Case Experience...",
  "categories": ["AI AND AUTOMATION", "TEXT"],
  "compatibility": ["CLIO MANAGE"],
  "regions": ["UNITED STATES"],
  "integrationUrl": "https://www.casestatus.com/clio",
  "scrapedAt": "2026-05-25T12:55:08.403Z",
  "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎯 | **Direct from the source.** Reads the live `/app-directory/` listing, not a stale third-party mirror. Every run reflects Clio's current ecosystem state. |
| 🧱 | **Flat, spreadsheet-ready schema.** 11 fields, no nesting, no JSON-inside-JSON. Drops straight into Sheets, Excel, Airtable, or any BI tool. |
| 🛡 | **Cloudflare-bypassed.** Uses a stealth browser with residential proxy. You never see a challenge page, and you never need to host a scraping infra yourself. |
| 🏷️ | **Real taxonomy.** Categories, partner tiers, and Clio-product compatibility come from Clio's own structured chips, not regex guessing. |
| 🌍 | **Region-aware.** Captures the full list of countries each app is officially available in, so you can segment by market. |
| 🔗 | **Outbound vendor URLs.** Resolves the partner "Get Started" link for each app, ready for outreach pipelines. |
| 📆 | **Dated snapshots.** Every record carries an ISO `scrapedAt` so you can run on a schedule and track ecosystem changes over time. |

> 📊 **300+ apps across 24 categories and 5 served regions in one run.** Pull the whole directory in under 20 minutes, or grab a 25-app sample in under 2.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Clio App Directory Scraper** *(this Actor)* | Pay per run | Full live directory | On demand or scheduled | Category + region enums | None, type a slug and run |
| Manual copy from the website | Free, slow | One app at a time | Stale the moment you finish | None | High, every cell by hand |
| Generic web-scraping framework | Engineering time | Whatever you code | Whatever you maintain | Whatever you code | Build + host + bypass Cloudflare yourself |
| Paid B2B SaaS marketplace databases | Subscription | Cross-vendor but shallow | Vendor cadence | Their UI | Sign contract, integrate API |
| Third-party app-marketplace mirrors | Free or freemium | Often outdated | Whenever they re-crawl | Limited | None, but data is days-to-weeks behind |

If you only need a one-off list, the manual approach works. For anything you want to repeat, segment, or feed into a pipeline, a maintained scraper saves the engineering bill.

***

### 🚀 How to use

1. ✍️ **Sign in or sign up to Apify.** Create a free account at [console.apify.com](https://console.apify.com/sign-up?fpr=vmoqkp), takes about 30 seconds.
2. 🔎 **Open this Actor.** Search for "Clio App Directory Scraper" in the Apify Store and click **Try for free**.
3. ⚙️ **Configure your inputs.** Set `maxItems`, optionally pick a `categorySlug` (e.g. `time-tracking`) and/or `regionSlug` (e.g. `united-states`).
4. ▶️ **Click Start.** The actor warms up Clio, clears the Cloudflare challenge once, then streams records into your dataset in real time.
5. 📥 **Export.** Download as CSV, Excel, JSON, XML, RSS, or HTML, or hit the dataset API from your own code.

> ⏱️ Total time: **about 90 seconds** for the first 10 apps, scaling roughly linearly from there.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 💼 Legal-tech founders and product teams

- Map every app in your category before launching a Clio integration
- Spot underserved niches by comparing app counts across categories
- Benchmark your tagline length, supported regions, and tier against direct competitors
- Track newcomers and emerging partner tiers month-over-month

</td>
<td width="50%">

#### 🤝 Partnership and BD teams

- Build a target list of complementary apps for co-marketing or bundling
- Identify partners whose regions overlap with yours for joint go-to-market
- Filter to apps without a `partnerTier` to find growth-stage outreach targets
- Resolve vendor "Get Started" URLs and pipe them straight into outbound tools

</td>
</tr>
<tr>
<td width="50%">

#### 📈 Investors and market analysts

- Track ecosystem growth: total app count, partner-tier distribution, category density
- Quantify Clio's reach by counting apps available in each region
- Identify acquisition or investment targets among UNICORN-tier partners
- Compare snapshots across quarters to measure platform momentum

</td>
<td width="50%">

#### 🏢 Law-firm IT, operations, and consultants

- Find every integration compatible with the Clio products your firm already runs
- Filter by region to surface only apps available in your jurisdiction
- Build internal vendor evaluation lists for partner selection and procurement
- Audit which app categories your firm has covered and which are gaps

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Clio App Directory Scraper

Trigger this actor from any code that can hit an HTTPS endpoint, then pull the dataset programmatically. Apify ships official SDKs for the most common stacks.

- **[Node.js / TypeScript SDK](https://docs.apify.com/sdk/js/)** for in-app calls or serverless functions
- **[Python SDK](https://docs.apify.com/sdk/python/)** for data-science notebooks and ETL pipelines
- **[REST API reference](https://docs.apify.com/api/v2)** for any other language

**Schedules**: pin a daily, weekly, or monthly run from the [Apify Scheduler](https://docs.apify.com/platform/schedules) and the actor will refresh the directory automatically. Dataset retention defaults to 7 days, configurable up to indefinite on paid plans.

***

### ❓ Frequently Asked Questions

<details>
<summary><strong>❓ Is this data public?</strong></summary>

Yes. Everything the actor returns is visible to any visitor on Clio's public App Directory at `/app-directory/`. No login, no paywall, no internal endpoints.

</details>

<details>
<summary><strong>📦 How many apps does the actor return?</strong></summary>

Clio publishes around **300 apps across roughly 38 pages**. The actor paginates through the full set, capped by your `maxItems` input.

</details>

<details>
<summary><strong>🏷 What categories can I filter by?</strong></summary>

24 category slugs are exposed as a dropdown in the input schema, including `accounting`, `billing-payments`, `document-automation`, `e-signatures`, `phone-systems`, `time-tracking`, and more. Leave the field empty to pull every category.

</details>

<details>
<summary><strong>🌍 Which regions does it cover?</strong></summary>

Each app lists its supported regions (e.g. United States, Canada, United Kingdom, Australia, Europe, Global). You can filter the listing by region at input time or analyze the full mix in the output.

</details>

<details>
<summary><strong>🏅 What does `partnerTier` mean?</strong></summary>

Clio assigns tier badges like `UNICORN`, `GOLD`, `SILVER`, `BRONZE`, and `CERTIFIED` to highlight strategic partners. Most apps have no tier (the field is `null` in those cases), which is normal and expected.

</details>

<details>
<summary><strong>⏱ How long does a run take?</strong></summary>

About **90 seconds for 10 apps**, scaling roughly linearly. The full ~300-app directory takes 15-20 minutes on a typical run because Clio is behind Cloudflare and each detail page is fetched in a real browser.

</details>

<details>
<summary><strong>🛡 Why does it use a stealth browser?</strong></summary>

Clio.com sits behind Cloudflare's interactive challenge. Plain HTTP requests get blocked with a "Just a moment..." page. The actor runs a real Firefox-based stealth browser through a residential proxy to clear the challenge once per run.

</details>

<details>
<summary><strong>💰 Can I use this data commercially?</strong></summary>

The data is public. Whether you can use it commercially depends on Clio's terms of service and your local laws around publicly accessible data. If you're building a commercial product, please review Clio's terms and consult your own legal counsel.

</details>

<details>
<summary><strong>💳 Do I need a paid Apify plan?</strong></summary>

No. Free users can pull up to 10 apps per run (preview tier). Paid plans lift that to 1,000,000 items and give you scheduled runs, longer dataset retention, and bigger proxy budgets.

</details>

<details>
<summary><strong>🆘 What if my run fails?</strong></summary>

Each error record carries an `error` field instead of data, and the run continues for the rest of the inputs. If the run itself fails outright, the [Apify Console](https://console.apify.com) shows logs, and our [contact form](https://tally.so/r/BzdKgA) is the fastest way to get help.

</details>

<details>
<summary><strong>⚖️ Is this affiliated with Clio?</strong></summary>

No. This is an independent third-party tool. Clio is a trademark of Themis Solutions Inc. The actor only collects data that's publicly available on Clio's website.

</details>

<details>
<summary><strong>🔄 How often should I run it?</strong></summary>

For ecosystem monitoring, monthly is usually enough; Clio's directory changes gradually. For competitive monitoring of a specific category, weekly gives you a tighter feedback loop. Schedules are configurable in the Apify Console.

</details>

***

### 🔌 Integrate with any app

Pipe the dataset into the tools your team already uses:

- [**Make (Integromat)**](https://apify.com/integrations) - drag-and-drop automations that react to each new app
- [**Zapier**](https://apify.com/integrations) - send new records straight into CRM, Slack, or Notion
- [**Airbyte**](https://apify.com/integrations) - schedule the dataset into Snowflake, BigQuery, or Postgres
- [**GitHub Actions**](https://docs.apify.com/api/v2) - trigger workflows when the dataset updates
- [**Google Drive**](https://apify.com/integrations) - drop CSV exports straight into a shared folder
- [**Slack**](https://apify.com/integrations) - post a daily digest to a channel when new apps appear

***

### 🔗 Recommended Actors

If you scrape one B2B marketplace, you usually scrape several. These ParseForge actors pair well with this one:

- [**🛒 HubSpot Marketplace Scraper**](https://apify.com/parseforge/hubspot-marketplace-scraper) - every app in the HubSpot integration catalog, structured the same way
- [**💳 Stripe App Marketplace Scraper**](https://apify.com/parseforge/stripe-marketplace-scraper) - the full Stripe app directory for fintech integration mapping
- [**☁️ AWS Marketplace Scraper**](https://apify.com/parseforge/aws-marketplace-scraper) - SaaS, ML, and infra listings across the AWS Marketplace
- [**🧠 Smart Apify Actor Scraper**](https://apify.com/parseforge/smart-apify-actor-scraper) - 70+ fields per Apify actor for SaaS catalog research
- [**🛡 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - regulated-professional directory data for adjacent compliance research

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more directory and marketplace scrapers across legal, financial, and SaaS verticals.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and we'll get back to you within one business day.

***

> **⚠️ Disclaimer:** this is an independent third-party tool. It is not affiliated with, endorsed by, or sponsored by Clio or Themis Solutions Inc. Only publicly available data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `categorySlug` (type: `string`):

Filter integrations by category. Leave empty to scrape every category.

## `regionSlug` (type: `string`):

Filter integrations by supported region. Leave empty to include every region.

## Actor input object example

```json
{
  "maxItems": 10,
  "categorySlug": "",
  "regionSlug": ""
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/clio-app-directory-scraper").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/clio-app-directory-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/clio-app-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/clio-app-directory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clio App Directory Scraper",
        "description": "Scrape 300+ legal-tech integrations from Clio's App Directory: app names, categories, supported Clio products, vendor links and more.",
        "version": "0.1",
        "x-build-id": "DSotCT8DvzJr6xydO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~clio-app-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-clio-app-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~clio-app-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-clio-app-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~clio-app-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-clio-app-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "categorySlug": {
                        "title": "Category",
                        "enum": [
                            "",
                            "accounting",
                            "automation",
                            "billing-payments",
                            "case-management",
                            "calendar",
                            "client-intake",
                            "client-portal",
                            "client-relationship-management",
                            "communication",
                            "court-filings",
                            "document-automation",
                            "document-management",
                            "e-signatures",
                            "email",
                            "marketing",
                            "phone-systems",
                            "practice-management",
                            "productivity",
                            "reporting-analytics",
                            "research",
                            "scheduling",
                            "tasks-workflow",
                            "time-tracking",
                            "voip",
                            "website-online-presence"
                        ],
                        "type": "string",
                        "description": "Filter integrations by category. Leave empty to scrape every category.",
                        "default": ""
                    },
                    "regionSlug": {
                        "title": "Region",
                        "enum": [
                            "",
                            "united-states",
                            "canada",
                            "united-kingdom",
                            "australia",
                            "europe",
                            "global"
                        ],
                        "type": "string",
                        "description": "Filter integrations by supported region. Leave empty to include every region.",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
