# FDA Warning Letter and Enforcement Monitor (`george.the.developer/fda-warning-letter-monitor`) Actor

Monitor FDA warning letters, classify GLP-1 and telehealth risk signals, and generate company enforcement briefs.

- **URL**: https://apify.com/george.the.developer/fda-warning-letter-monitor.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** Business, News
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-usage

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

## FDA Warning Letter and Enforcement Monitor

FDA's April 2026 GLP-1 push reset the compliance bar. Watching for warning letters by hand is yesterday's job.

This Actor monitors FDA warning letters, normalizes each letter into a clean JSON schema, classifies regulatory topics with deterministic rules, and produces company risk briefs for diligence, QA, legal, and compliance workflows. It is built for analysts and builders who need FDA enforcement signals in an API shape, not another browser tab.

The monitor uses the public FDA warning letter index, per letter detail pages, and openFDA enforcement APIs for drug, device, and food recalls. It does not use an LLM. Topic labels come from transparent keyword and phrase rules for GLP-1, telehealth, compounding, manufacturing, biologics, device, advertising, dietary supplement, food, and other.

### Quick Start

Recent warning letters by topic:

```bash
curl "https://YOUR-STANDBY-URL.apify.actor/letters?since=2026-04-01&limit=10&topic=manufacturing"
````

Company risk brief:

```bash
curl "https://YOUR-STANDBY-URL.apify.actor/brief?company=Respilon%20Production%20S.R.O."
```

### What You Get

Each warning letter row is normalized into:

| Field | Description |
|---|---|
| `letter_id` | Last path segment of the FDA detail URL |
| `letter_url` | FDA detail page |
| `issued_date` | ISO date from the FDA letter issue date |
| `company_name` | Company named by FDA |
| `company_address` | Parsed recipient address when present |
| `subject` | FDA warning letter subject from the index |
| `topics` | Deterministic topic labels |
| `issuing_office` | FDA office or center |
| `violation_summary` | First substantive findings from the letter body |
| `product_categories` | Drug, device, food, biologic, supplement, or tobacco labels |
| `response_required_days` | Parsed response window when FDA states one |
| `fetched_at` | Fetch timestamp |

Company briefs roll those letters into a risk view:

| Field | Description |
|---|---|
| `letter_count_1y` | Warning letters in the last year |
| `letter_count_3y` | Warning letters in the last 3 years |
| `letter_count_all` | Warning letters returned by FDA index search |
| `topics_observed` | Unique topic labels |
| `repeat_violation_topics` | Topics seen at least twice |
| `enforcement_actions` | openFDA drug, device, and food enforcement rows |
| `risk_band` | low, medium, high, or critical |
| `risk_rationale` | Short explanation of the band |

### Workflow

```mermaid
flowchart LR
    A[Input: date, topic, company, or letter URL] --> B[Fetch FDA index and detail pages]
    B --> C[Parse HTML with Cheerio]
    C --> D[Normalize warning letter schema]
    D --> E[Classify topics with deterministic rules]
    E --> F[Push rows to Apify dataset]
    E --> G[Optional company brief aggregation]
    G --> H[openFDA enforcement lookup]
    H --> I[Risk band and rationale]
```

### Endpoints

| Endpoint | Purpose |
|---|---|
| `GET /` | Service metadata |
| `GET /health` | Service metadata for monitoring |
| `GET /letters?since=<date>&limit=<N>&topic=<topic>` | Recent warning letters |
| `GET /letter?id=<letter_id_or_url>` | One full normalized warning letter |
| `GET /brief?company=<name>` | Company risk brief |
| `GET /enforcement?type=<drug|device|food>&since=<date>&limit=<N>` | openFDA enforcement rows |
| `POST /brief/bulk` | Up to 50 company briefs in one request |

### Pricing

| Event | Price | When charged |
|---|---:|---|
| Actor start | $1.00 | Once per paid batch run |
| Warning letter | $0.30 | Per normalized warning letter or enforcement row returned |
| Risk brief | $1.50 | Per company risk brief generated |

Health probes and known test payloads are short circuited and are not charged.

### Comparison

openFDA is excellent raw infrastructure. It gives you recall and enforcement JSON, but it does not normalize FDA warning letter HTML, classify GLP-1 or telehealth signals, or produce a company risk brief.

Redica and similar enterprise platforms are strong compliance systems for large teams. They are also enterprise SaaS products with enterprise sales cycles and budgets. This Actor is positioned as the API for builders, analysts, consultants, and QA teams that need enforcement signals inside their own workflow.

### Use Cases

1. Compliance vendor monitoring: track new FDA letters by topic and route them into customer intelligence.
2. Med device QA daily check: watch warning letters and device enforcement rows for competitor and supplier risk.
3. Pharma diligence: screen acquisition targets and manufacturers for repeat FDA topics.
4. Telehealth ops risk: monitor GLP-1, compounding, advertising, and remote prescribing signals.
5. Food industry weekly digest: summarize food safety and adulteration letters for QA leaders.

### FAQ

**Does this cover all FDA enforcement?**\
No. It covers FDA warning letters from the public warning letter index and openFDA drug, device, and food enforcement APIs.

**How accurate is classification?**\
Classification is deterministic keyword and phrase matching. It is transparent and repeatable, but it is not legal advice.

**How often should I run it?**\
Daily is enough for most monitoring. High urgency teams can poll more often through Standby mode.

**Does it include FOIA only records or FDA 483s?**\
No. It only uses public FDA web pages and openFDA APIs available without authentication.

**Can I get a refund for empty results?**\
Empty warning letter and enforcement responses do not trigger per row charges. Risk briefs are charged when generated.

**Who do I contact for custom fields or bulk monitoring?**\
Contact the Actor owner through Apify for custom exports, account level monitoring, or integration work.

# Actor input Schema

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

Run mode for batch execution.

## `since` (type: `string`):

ISO date filter such as 2026-04-01.

## `limit` (type: `integer`):

Maximum rows to return.

## `topic` (type: `string`):

Optional topic filter such as glp-1, telehealth, compounding, manufacturing, device, food, or advertising.

## `id` (type: `string`):

FDA warning letter slug or full FDA.gov URL.

## `company` (type: `string`):

Company name for a risk brief.

## `companies` (type: `array`):

Company names for bulk risk briefs, max 50.

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

openFDA enforcement product class for enforcement mode.

## Actor input object example

```json
{
  "mode": "letters",
  "since": "2026-04-01",
  "limit": 25,
  "company": "Respilon Production S.R.O.",
  "type": "drug"
}
```

# 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("george.the.developer/fda-warning-letter-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("george.the.developer/fda-warning-letter-monitor").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 '{}' |
apify call george.the.developer/fda-warning-letter-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=george.the.developer/fda-warning-letter-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Warning Letter and Enforcement Monitor",
        "description": "Monitor FDA warning letters, classify GLP-1 and telehealth risk signals, and generate company enforcement briefs.",
        "version": "1.0",
        "x-build-id": "Q6VCTWCroyFBleobm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/george.the.developer~fda-warning-letter-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-george.the.developer-fda-warning-letter-monitor",
                "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/george.the.developer~fda-warning-letter-monitor/runs": {
            "post": {
                "operationId": "runs-sync-george.the.developer-fda-warning-letter-monitor",
                "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/george.the.developer~fda-warning-letter-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-george.the.developer-fda-warning-letter-monitor",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "letters",
                            "letter",
                            "brief",
                            "brief-bulk",
                            "enforcement"
                        ],
                        "type": "string",
                        "description": "Run mode for batch execution.",
                        "default": "letters"
                    },
                    "since": {
                        "title": "Since date",
                        "type": "string",
                        "description": "ISO date filter such as 2026-04-01.",
                        "default": "2026-04-01"
                    },
                    "limit": {
                        "title": "Limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum rows to return.",
                        "default": 25
                    },
                    "topic": {
                        "title": "Topic",
                        "type": "string",
                        "description": "Optional topic filter such as glp-1, telehealth, compounding, manufacturing, device, food, or advertising."
                    },
                    "id": {
                        "title": "Letter ID or URL",
                        "type": "string",
                        "description": "FDA warning letter slug or full FDA.gov URL."
                    },
                    "company": {
                        "title": "Company",
                        "type": "string",
                        "description": "Company name for a risk brief.",
                        "default": "Respilon Production S.R.O."
                    },
                    "companies": {
                        "title": "Companies",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Company names for bulk risk briefs, max 50.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "type": {
                        "title": "Enforcement type",
                        "enum": [
                            "drug",
                            "device",
                            "food"
                        ],
                        "type": "string",
                        "description": "openFDA enforcement product class for enforcement mode.",
                        "default": "drug"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
