# ClinicalTrials Monitor: New Trials & Status Changes (MCP) (`amygraphics/clinical-trials-monitor`) Actor

Official ClinicalTrials.gov API v2 for AI agents: search 500k+ studies by condition or drug (status, phase, country filters), pull full trial records, and monitor watch queries for new trials and status changes. No key. MCP-ready.

- **URL**: https://apify.com/amygraphics/clinical-trials-monitor.md
- **Developed by:** [Zakaria el bouami](https://apify.com/amygraphics) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ClinicalTrials Monitor: New Trials & Status Changes (MCP)

Every clinical trial on Earth — **500,000+ studies from the official ClinicalTrials.gov API v2**, no key, no login. Search by condition, drug or sponsor-side filters; pull a full trial by NCT id; or watch terms and get alerted on **new trials** and the moment a study flips `RECRUITING → COMPLETED → TERMINATED`. MCP-compatible, agent-ready.

### Who pays for this data

Pharmaceutical ops teams, CROs, medical writers, investors' research desks, patient-recruitment agencies and university labs all monitor the registry — usually by hand. Status changes matter: a big trial going `COMPLETED` means results are coming; `TERMINATED` means a competitor's candidate just died. This actor turns that ritual into a schedule + a webhook.

### What you get per row

`nctId`, `briefTitle`, `overallStatus`, `phase`, `studyType`, `conditions`, `interventions` (drugs/devices), `leadSponsor` + `sponsorClass` (INDUSTRY/OTHER), `enrollmentCount` & type (ACTUAL/ESTIMATED), `startDate` / `primaryCompletion` / `completionDate`, `lastUpdate`, age limits, sex, location countries, and the direct trial URL.

### Three modes

#### `search` — find studies

```json
{ "mode": "search", "query": "semaglutide", "status": "RECRUITING", "country": "Germany", "phase": "3", "maxResults": 10 }
```

#### `trial` — one study, full record

```json
{ "mode": "trial", "nctId": "NCT07212530" }
```

#### `monitor` — never miss a move

```json
{ "mode": "monitor", "watchQueries": ["diabetes", "tirzepatide|RECRUITING@United States"], "maxResults": 20 }
```

- **Run 1 = free baseline** — snapshot of the latest-updated studies for each watch query.
- **Run 2+** emits only: `new-trial` (within your tracked set: appeared in the latest-updated sample) and `status-changed` (with old → new in `info`).
- Schedule daily; a quiet day costs **$0.001** (start only).

### Data honesty & limits

- Every field comes from the official ClinicalTrials.gov API at run time; estimated dates are marked by the source (we surface the enrollment `type` so you can tell ESTIMATED from ACTUAL).
- Monitor covers the **most recently updated** studies per watch query (top 60 sorted by last-updated) — deep-archive sweeps belong to search mode. Say a popular condition like "diabetes" gets hundreds of updates per day: raise the sample by splitting watches (`diabetes|RECRUITING@France` …) for full coverage.
- No adverse-event narratives, no results-section parsing — those live in separate endpoints and can be added on request (Issues tab).

### Recipes

1. **Pipeline radar for pharma BD** — watch a competitor's drug name; get pinged when a phase-3 trial posts or completes.
2. **Patient recruitment** — agents find `RECRUITING` trials in a country for a condition and hand the rows to outreach.
3. **Literature/med-writer brief** — search a condition, export the last-N updated records with sponsor and enrollment.

### Pricing

| event | price |
|---|---|
| Actor start | $0.001 |
| Clinical trial record | $0.001 / row |

Typical runs: enriched 10-row search ≈ **$0.011** · daily monitor with 2 changes ≈ **$0.003**.

### MCP / AI-agent usage

```
https://api.apify.com/v2/acts/YOUR_HANDLE~clinical-trials-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN
```

Input = the JSON examples above. Output = rows as documented. Compatible with per-request agentic payments.

Questions / module requests (results, references, adverse events): **Issues** tab on Apify Store.

# Actor input Schema

## `mode` (type: `string`):

search = find studies by condition/drug (+filters) · trial = one NCT id in full · monitor = alert on new trials & status changes for your watch queries.

## `query` (type: `string`):

(search/monitor) Condition, disease or drug name, e.g. "diabetes", "semaglutide", "asthma".

## `country` (type: `string`):

(search) Only trials recruiting in this country, e.g. "Germany" or "France".

## `status` (type: `string`):

(search) RECRUITING | COMPLETED | ACTIVE_NOT_RECRUITING | SUSPENDED | NOT_YET_RECRUITING — empty = any.

## `phase` (type: `string`):

(search) e.g. "3" for phase 3 only, "2,3" for phases 2-3.

## `nctId` (type: `string`):

(trial) Full record for one study, e.g. NCT04280705.

## `watchQueries` (type: `array`):

(monitor) Terms to watch; optional |STATUS and @Country: \["diabetes", "semaglutide|RECRUITING@United States"]. Each run scans the most recently updated studies per query and reports new trials and status changes.

## `maxResults` (type: `integer`):

Cap rows returned per run (each billed row $0.001).

## `requestDelaySecs` (type: `number`):

Politeness delay between API requests. Keep >= 0.2.

## Actor input object example

```json
{
  "mode": "search",
  "query": "",
  "country": "",
  "status": "",
  "phase": "",
  "nctId": "",
  "watchQueries": [],
  "maxResults": 10,
  "requestDelaySecs": 0.4
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("amygraphics/clinical-trials-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("amygraphics/clinical-trials-monitor").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 '{}' |
apify call amygraphics/clinical-trials-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,amygraphics/clinical-trials-monitor"
        }
    }
}
```

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/M9Cq3KfENtWSs6pOf/builds/NjZ1cTqvnTQve9Atd/openapi.json