# Clinical Trials Search — ClinicalTrials.gov to JSON (`oblanceolate_mandola/clinical-trials-search`) Actor

Search ClinicalTrials.gov by condition, drug or sponsor. Trial title, status, phase, sponsor, NCT id as JSON for pharma & biotech AI agents. $4 per 1,000, no coding.

- **URL**: https://apify.com/oblanceolate\_mandola/clinical-trials-search.md
- **Developed by:** [Hassan Hashish](https://apify.com/oblanceolate_mandola) (community)
- **Categories:** Business, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

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

## Clinical Trials Search — ClinicalTrials.gov to JSON

Search ClinicalTrials.gov by condition, drug or sponsor and get trial title, status, phase, sponsor and NCT id as JSON — $0.004 per trial.

Clinical trial activity is a leading signal of pharma and biotech pipelines. This actor turns a condition, drug, or sponsor into the matching registered studies, so healthcare, investment, and competitive-intelligence agents can read the trial landscape as structured data.

### What this actor does

- Search ClinicalTrials.gov by condition, intervention/drug, or sponsor
- Each result: brief title, recruitment status, phase, lead sponsor, conditions, NCT id
- Open any study at clinicaltrials.gov/study/{nctId}
- Batch many terms per run; cap spend with maxResults
- Agent-ready: flat JSON with sourceUrl + scrapedAt for citation

**You only pay for successful results** — failed or empty lookups cost nothing.

### Why pick this Actor

- Stable NCT IDs, recruiting status, sponsor, conditions, and phases via the official ClinicalTrials.gov v2 API
- Per-result pricing ($0.004/result) with a hard `maxResults` spend cap — empty lookups cost $0
- Flat, stable JSON schema with `sourceUrl` + `scrapedAt` on every item — citation-ready for RAG and grounding
- Batch many queries in one run; overlapping results are deduplicated and charged once
- MCP server, OpenAPI schema, and LangChain/CrewAI tool support out of the box — no glue code

### Sample output

Each dataset item is flat, typed JSON with a `sourceUrl` and `scrapedAt` for citation/grounding:

```json
{
  "query": "diabetes",
  "source": "clinical_trials",
  "title": "Effect of Diet on Type 2 Diabetes",
  "status": "COMPLETED",
  "sponsor": "University Hospital",
  "nctId": "NCT00471549",
  "conditions": [
    "Diabetes Mellitus, Type 2"
  ],
  "sourceUrl": "https://clinicaltrials.gov/api/v2/studies?query.term=diabetes",
  "scrapedAt": "2026-06-11T09:00:00.000Z"
}
```

### Input

```json
{"queries":["diabetes"]}
```

| Field | Type | Description |
|---|---|---|
| `queries` / `query` | array / string | Condition, drug, or sponsor. One or many. |
| `maxResults` | integer | Hard spend cap (billed per result). |
| `keywords` / `postedAfter` | filters | Narrow results; enable delta/scheduled runs. |

### How much does it cost

Pay-per-result: **$0.004 per successful result.** No subscription, no compute-unit guesswork, no charge for empty results. An orchestrator can cap spend with `maxResults`.

### How to use it with AI agents (MCP), Claude, and the API

#### Claude Desktop / Claude Code via Apify MCP

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "oblanceolate_mandola/clinical-trials-search"],
      "env": { "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>" }
    }
  }
}
```

#### Python (Apify API)

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("oblanceolate_mandola/clinical-trials-search").call(run_input={"queries":["diabetes"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### TypeScript (Apify API)

```ts
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('oblanceolate_mandola/clinical-trials-search').call({"queries":["diabetes"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### LangChain / CrewAI tool

```python
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("oblanceolate_mandola/clinical-trials-search")  # agent calls it autonomously
```

OpenAPI schema for self-integrating GPT agents is auto-exposed at the Actor's API tab.

### Data & compliance

Reads only publicly accessible endpoints. No login, no credential harvesting, no CAPTCHA bypass. Every result carries its `sourceUrl` so downstream agents can cite and re-verify.

### FAQ

#### How do I open a study?

Each result includes its NCT id; the study page is clinicaltrials.gov/study/{nctId}.

#### Can I track a company’s pipeline?

Yes — search by sponsor name and schedule with postedAfter for new-trial alerts.

#### What is the source?

The official ClinicalTrials.gov v2 API (US National Library of Medicine).

#### Can AI agents call this Actor directly?

Yes — via the Apify MCP server (snippet above), the OpenAPI schema on the Actor's API tab, or the LangChain/CrewAI tool wrapper. Results are flat JSON with `sourceUrl` and `scrapedAt` on every item, so downstream agents can cite and re-verify.

#### What happens when there are no results?

You pay nothing. Billing is per dataset item delivered, so an empty lookup costs $0, and the run log states why (no match, source rate limit) instead of failing silently.

### Changelog

- **1.0** — Initial release: clinical\_trials.

# Actor input Schema

## `queries` (type: `array`):

Term to search across registered clinical studies, e.g. "diabetes", "semaglutide", or a sponsor/company name. Pass several to batch them in one run. Either this or "query" is required.

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

Single-value convenience alias for "queries". Term to search across registered clinical studies, e.g. "diabetes", "semaglutide", or a sponsor/company name.

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

Hard cap on results across all queries — bounds spend programmatically (you are billed per result). Note: each query returns at most one page from the source (typically 50–100 results); pass multiple queries to gather more.

## `keywords` (type: `array`):

Only return results whose title/department/team contains one of these as a whole word (case-insensitive) — "ai" matches "AI Engineer" but not "Maintenance".

## `postedAfter` (type: `string`):

Only return results posted on/after this ISO date (strictly YYYY-MM-DD, e.g. 2026-01-01; anything else fails the run). Items with no posted date are excluded. Enables incremental/delta scheduled runs.

## `proxyConfiguration` (type: `object`):

Most sources are public JSON APIs needing no proxy. Configure only if a source geo-restricts.

## Actor input object example

```json
{
  "queries": [
    "diabetes"
  ],
  "maxResults": 50
}
```

# Actor output Schema

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

Structured result rows in the default dataset (clean JSON).

# 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 = {
    "queries": [
        "diabetes"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("oblanceolate_mandola/clinical-trials-search").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 = { "queries": ["diabetes"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=oblanceolate_mandola/clinical-trials-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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