# Press Release Monitor API — PR Newswire (`nexgensignal/press-release-monitor-api`) Actor

Monitor PR Newswire press releases by company, topic, and date. Company-watch/delta mode delivers only new releases since last run. Structured JSON, keyless, pay per release, no person data.

- **URL**: https://apify.com/nexgensignal/press-release-monitor-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 press releases

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/actors/running/actors-in-store.md#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

## Press Release Monitor API — PR Newswire by Company, Topic & Date

**Pay per release. Monitor PR Newswire's public press-release stream — filter by company, topic, and date, and turn on company-watch to receive only new releases since your last run.**

Point this actor at a keyword and get back a clean JSON record for each matching PR Newswire press release: the headline, the issuing company, the location, the date, a summary, a link back to the original, and — if you ask for it — the full body. Run it for a snapshot, or turn on **company-watch** and run it on a schedule to receive only the releases that are new since last time.

### What this is, in one paragraph

PR Newswire distributes tens of thousands of corporate press releases, and its public RSS stream is the cleanest way to watch them. This actor reads that public feed with a **retry-in-front, four-attempt fetch** (each retry on a fresh proxy session, so a transient block never sinks a run), parses each release into a structured record — headline, company and location pulled from the standard PR Newswire dateline, date, summary, and source link — and delivers it. The upgrade over a plain scraper is a **company-watch / delta layer**: give a run a `watchLabel`, turn on `newSinceLastRun`, and the actor remembers what it has already delivered and hands you only the new releases on each subsequent run, so a scheduled monitor bills only genuinely new activity.

### Who buys this and for what job

- **PR and comms teams** monitoring a company, a competitor set, or a topic for new announcements.
- **Media and analysts** tracking corporate news flow in a sector without babysitting a feed reader.
- **Sales and BD teams** watching for trigger events — launches, partnerships, expansions — in named accounts.
- **Builders and agents** who need a keyless, structured press-release feed they can poll on a schedule.

### The upgrade: company-watch / delta and hardened fetch

Two upgrades sharpen this over a straight scraper. First, **retry-in-front hardening**: the feed fetch runs up to four attempts, each on a fresh proxy session, so a single refused request is absorbed rather than fatal. Second, a **company-watch / delta mode**: with `newSinceLastRun` on and a `watchLabel` set, the actor keeps a memory of every release it has already delivered under that label and, on the next run, delivers only the new ones — marked `is_new`. A daily watch on a company or topic then costs only what the new releases cost, not a re-scan of the whole feed.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `apify-actor-start` | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| `apify-default-dataset-item` | $0.05 | $0.045 | $0.04 | $0.0335 |

A negligible start fee plus one item charge per release delivered. Delivered before charged.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keyword` | string | — | Company or topic to filter releases (matched against title + summary). |
| `dateFrom` | string | — | Only releases on/after this date (YYYY-MM-DD). |
| `dateTo` | string | — | Only releases on/before this date (YYYY-MM-DD). |
| `includeFullBody` | boolean | false | Fetch each release page for the full body text. |
| `maxReleases` | integer | 100 | Maximum releases delivered (1–1000). |
| `newSinceLastRun` | boolean | false | **Company-watch/delta:** deliver only releases new since the last run for this label. |
| `watchLabel` | string | keyword | Namespace for the company-watch memory. |
| `proxyConfiguration` | object | Residential | Apify proxy for the hardened fetch. |

### Output

One JSON object per press release. Real example:

```json
{
  "record_id": "prn:302859770",
  "title": "MillerKnoll Schedules First Quarter Fiscal Year 2027 Conference Call and Webcast",
  "company": "MillerKnoll",
  "location": "ZEELAND, Mich.",
  "summary": "MillerKnoll, Inc. (\"MillerKnoll\") today announced it will host a conference call...",
  "body": null,
  "date": "2026-08-25",
  "url": "https://www.prnewswire.com/news-releases/millerknoll-schedules-...-302859770.html",
  "is_new": true,
  "source": "PR Newswire public press releases (prnewswire.com)",
  "observed_at": "2026-08-25T00:00:00Z"
}
```

With `includeFullBody` on, `body` carries the full release text. An unbilled `RUN_RECEIPT` records the keyword, watch settings, and how many releases were found and delivered.

### Field reference

Each record carries `record_id` (the PR Newswire release id), `title`, `company` and `location` (parsed from the release dateline), `summary`, `body` (when requested), `date`, `url` and `source_url`, and `is_new` (set on watch runs). Provenance travels on every record: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

The actor fetches PR Newswire's public releases RSS with the four-attempt, rotating-session fetch, parses each item, and pulls the company and location from the standard PR Newswire dateline (`CITY, State, Date /PRNewswire/ -- Company ...`). It filters by your `keyword` (over title and summary) and by `dateFrom`/`dateTo`, de-duplicates by release id, and — on a company-watch run — drops anything already delivered under your `watchLabel`, emitting the rest marked `is_new` and saving the updated memory. If `includeFullBody` is on, each delivered release's page is fetched (through the same hardened path) for its full text.

### Working with the data

The `record_id` is stable per release, so it is a clean de-duplication and join key across runs. Run with a `keyword` to monitor a company or topic; add `dateFrom`/`dateTo` to bound a window; turn on company-watch and schedule it to get only new releases each morning, piped into a CRM, a Slack channel, or an agent's briefing. Leave `includeFullBody` off for a fast headline monitor, or turn it on when you need the release text for downstream analysis such as sentiment or entity extraction. The `company` and `location` fields, parsed from the standard PR Newswire dateline, let you group releases by issuer or region without a second pass over the text.

### Honest limitations

- **Issuer-authored publicity.** Press releases are written by their issuers and are not independently verified; each record links back to the original.
- **Public feed scope.** The monitor reads PR Newswire's public releases stream; keyword filtering is applied over that stream's title and summary.
- **No person data.** Only release-level metadata and body text are collected; no individual contact data is selected or emitted.

### Use with AI agents and schedules

The output is flat JSON keyed by a stable `record_id`, so an agent can call this actor as a tool and reason over the releases directly — "any new press releases from my watchlist of companies today?" is answerable by running with a `keyword` and `newSinceLastRun` on, then reading the `is_new` records. Paired with a scheduler, company-watch turns the actor into a standing monitor: a daily run delivers only the fresh releases, which pipe cleanly into a CRM, a Slack channel, or an agent's morning briefing. Because each run is bounded by `maxReleases` and priced per delivered release, the cost of a standing watch tracks the actual news flow and stays small and predictable.

### Differentiation

A **press-release monitor API** on PR Newswire's public feed, upgraded with retry-in-front fetch hardening and a company-watch / delta mode that delivers only new releases since the last run. Keyless, pay-per-release, callable from code or an AI agent, with residential-proxy hardening for reliability.

***

*Source: PR Newswire public press releases (prnewswire.com). Reformatted to per-release records, linking back to the source; each release remains the property of its issuer. No natural-person data of any kind.*

# Actor input Schema

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

Company or topic to filter releases (matched against title + summary).

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

Only releases on/after this date (YYYY-MM-DD).

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

Only releases on/before this date (YYYY-MM-DD).

## `includeFullBody` (type: `boolean`):

Fetch each release page for the full body text.

## `maxReleases` (type: `integer`):

Maximum releases delivered.

## `newSinceLastRun` (type: `boolean`):

Company-watch/delta: deliver ONLY releases not seen on a previous run for this watch label.

## `watchMode` (type: `boolean`):

Alias for 'New releases since last run'.

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

Namespace for the company-watch memory. Defaults to the keyword.

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

Apify proxy (residential recommended).

## Actor input object example

```json
{
  "includeFullBody": false,
  "maxReleases": 100,
  "newSinceLastRun": false,
  "watchMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Delivered records.

# 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 = {
    "maxReleases": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/press-release-monitor-api").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 = { "maxReleases": 100 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/press-release-monitor-api").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 '{
  "maxReleases": 100
}' |
apify call nexgensignal/press-release-monitor-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/press-release-monitor-api"
        }
    }
}

```

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/QnV5yL3S55vbADDwH/builds/WYlG0tKDI6Knnjzo0/openapi.json