RSS & Atom Feed Reader: New & Updated Items Monitor (Apify Actor)
Read public RSS, Atom and RDF feeds into JSON or CSV rows: title, link, date, summary and feed metadata, plus a run summary per feed. Monitor mode returns only new or updated items since the last saved baseline. No login or API key. Price: $0.75 per 1,000 saved item rows, plus $0.0056 per run start. Runs as an Apify Actor, callable from MCP clients via the Apify MCP server (https://mcp.apify.com/?tools=cliqtomedia/rss-atom-feed-reader-monitor).
ホスト型 MCP サーバー
npx add-mcp 'https://mcp.apify.com/?tools=cliqtomedia/rss-atom-feed-reader-monitor'Claude Code、Codex、Cursor などにインストールできます
ドキュメント
RSS & Atom Feed Reader: New & Updated Items Monitor (cliqtomedia/rss-atom-feed-reader-monitor) Actor
Read public RSS, Atom and RDF feeds into JSON rows. Monitor new and updated feed items.
- URL: https://apify.com/cliqtomedia/rss-atom-feed-reader-monitor.md
- Developed by: Cliqto Media (community)
- Categories: News, Developer tools, Automation
- Features: Limited permissions
- Stats: 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- User rating: No ratings yet
Pricing
from $0.53 / 1,000 saved feed 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/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 section below.
Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (pip install apify-client).
README
Read public RSS and Atom feeds into one Apify Dataset. Save article titles, links, dates, summaries, and feed metadata as JSON or CSV. Choose monitor mode to see which feed items are new or updated since the last saved baseline.
Start with the filled-in example in the Input tab. A small snapshot usually returns up to 10 item rows and one run summary. The applied price is $0.0056 at start for up to 1 GB, plus $0.00075 per saved item row; see Pricing for empty runs and limits.

Contents
- What it does
- Quick start
- Use cases
- Input fields
- Snapshot and monitor
- Input examples
- Output fields
- Output locations and special results
- Pricing and cost examples
- Limits and safe access
- Troubleshooting and FAQ
- Support
What it does
Use this Actor when you have one or more direct public RSS 2.0, RSS 1.0/RDF, or Atom 1.0 feed URLs. It reads each feed document, parses entries, and saves one ITEM row per selected item. The last row is a RUN_SUMMARY with the outcome of every feed, item counts, errors, and charge status.
It is useful for an RSS-to-JSON export, a list of recent blog posts, an Atom feed export, or a feed change monitor. Dates may be null when a feed does not supply a usable date. A feed can show only its most recent items; the Actor cannot recover older entries that the publisher removed from its feed window.
This Actor does not find a feed from a website homepage, read full linked articles, download podcast or image files, parse JSON Feed, sign in, or send alerts. It does not create a schedule or webhook. You can arrange repeat runs with Apify schedules yourself.
Quick start
- Open the Actor's Input tab and choose a new input. The form already contains
feedUrls: ["https://hnrss.org/frontpage"],maxItemsPerFeed: 10, andmaxItemsTotal: 10. - Leave
modeassnapshot, or keep the form's other default settings. Do not replace the feed with a website homepage. - Click Start. Open the Dataset tab after the run ends.
- Check that the first
ITEMhastitle,link,feedType, anditemKey. The last row isRUN_SUMMARY; checkfeedResultsandstatusthere. - Export the Dataset as JSON or CSV, or read it through the Apify API.
The form prefill is a small demo (10/10). The runtime defaults when those limits are omitted from an API request are 50 per feed and 1000 total. The feedUrls field is required; passing {} directly to the API is invalid and does not create a demo run.
Use cases
| Need | Key input | Result |
|---|---|---|
| Save the latest posts from a public blog | mode: "snapshot", feedUrls | ITEM rows with title, link, and optional dates |
| Read several RSS and Atom feeds | Several feedUrls, maxItemsTotal | Rows tagged with feedIndex, feedType, feedUrl |
| Find feed changes across runs | mode: "monitor", same stateKey and storage | NEW, UPDATED, and optional UNCHANGED / NO_LONGER_IN_CURRENT_FEED |
| Limit a topic list | includeKeywords, excludeKeywords | Filtered item rows and filteredCount in summary |
| Inspect a feed that gave no rows | Read final RUN_SUMMARY | Per-feed outcome, httpStatus, and errorCode |
Input fields
All fields live at the top level of one JSON object. Only feedUrls is required. null means no date bound or no named state key where allowed. The UI prefill is different from the runtime default. The list below covers all 21 fields.
| Field | Type; runtime default | UI prefill | Allowed values and effect |
|---|---|---|---|
feedUrls required | string array; no runtime default (schema suggests HN RSS) | https://hnrss.org/frontpage | 1–100 distinct direct public HTTP(S) feed URLs, max 2,048 characters each; no credentials or private targets |
mode | "snapshot" | none | snapshot or monitor; monitor compares a named stored baseline |
maxItemsPerFeed | integer 50 | 10 | 0–1,000 selected items per feed |
maxItemsTotal | integer 1000 | 10 | 0–5,000 saved item rows per run |
sort | "source" | none | source (feed order) or publishedDesc (newest valid dates first) |
publishedAfter | string or null; null | none | ISO-compatible date; keep items at or after this instant |
publishedBefore | string or null; null | none | ISO-compatible date; keep items before this instant |
includeKeywords | string array; [] | none | Up to 20 terms, each 1–200 characters; match title, summary, or feed content, case-insensitive |
excludeKeywords | string array; [] | none | Up to 20 terms, each 1–200 characters; exclude matching items |
dedupeAcrossFeeds | boolean false | none | Remove repeated articles from several feeds; keeps first copy |
includeContent | boolean false | none | Save optional content present inside the feed; never fetch article pages |
maxSummaryChars | integer 4000 | none | 100–10,000 characters per summary |
maxContentChars | integer 20000 | none | 1,000–100,000 characters per feed-provided content field |
requestTimeoutMs | integer 15000 | none | 3,000–60,000 milliseconds per feed request |
maxRetries | integer 2 | none | 0–3 retries for temporary request failures |
maxConcurrency | integer 5 | none | 1–10 feeds fetched at once |
stateKey | string or null; null | none | Optional monitor name, 1–63 characters: letters, digits, ., _, :, - |
resetState | boolean false | none | In monitor mode, start a fresh baseline for this scope |
emitBaselineItems | boolean false | none | Include baseline items as NEW rows on first monitor run |
emitUnchanged | boolean false | none | Save unchanged monitor rows; these are item-chargeable |
emitNoLongerCurrent | boolean false | none | Save items absent from the next complete feed window; not a deletion claim |
Interactions. Both date bounds must form a valid increasing time range. An item with no valid publication date may not pass a date filter. Keyword include and exclude rules are applied to feed fields, and multiple entries or filters can reduce output. maxItemsTotal limits emitted rows after filtering and optional dedupe; it does not expand what a feed publisher supplies. Monitor-only fields (stateKey, resetState, and the three emit* switches) require mode: "monitor". Use a stable stateKey for a recurring monitor. Monitor baselines also depend on the same Actor storage and input scope. A changed feed list or significant filter settings can create a different comparison scope.
maxItemsPerFeed: 0 or maxItemsTotal: 0 can lead to no item rows. An empty array for feedUrls, duplicate canonical URLs, unknown fields, invalid types, unsafe URLs, or conflicting dates generate INVALID_INPUT in the run summary. There is no automatic feed discovery or fallback URL. A valid run with no matched items still returns a summary.
Snapshot and monitor
Snapshot returns the items visible in the current feed document. Each returned row has changeType: "SNAPSHOT". You can run it again to get another snapshot without changing a monitor baseline.
Monitor compares the current feed window with saved state. The first successful observation creates a baseline. By default, baseline rows and unchanged items are not emitted, so a quiet monitor may return only the summary. With emitBaselineItems: true, the first baseline also emits NEW item rows. Later complete observations can emit NEW or UPDATED; optional emitUnchanged adds UNCHANGED. Optional emitNoLongerCurrent adds NO_LONGER_IN_CURRENT_FEED for an item missing from a complete later window. Every such row has deletionConfirmed: false because rolling feeds drop old items without deleting articles.
When a feed request fails, is partial, or returns an HTTP 304 conditional response, the Actor keeps the prior baseline where necessary. It does not call a failed/partial response a complete empty feed or invent mass deletions. State is versioned, bounded, and stored in an Actor key-value store named for this monitor. Give separate independent jobs different stateKey values and store contexts. resetState resets only the selected monitor scope. Do not use the Actor's monitoring storage for unrelated workloads.
Input examples
Read up to 10 recent items
{
"feedUrls": ["https://hnrss.org/frontpage"],
"mode": "snapshot",
"maxItemsPerFeed": 10,
"maxItemsTotal": 10
}
Expected: up to 10 ITEM rows with feedType: "rss2" when the source is available, then one RUN_SUMMARY. The number and dates can change as the source feed changes. This is also the exact prefilled input except that the form obtains mode from its runtime default.
Compare later runs of one monitor
{
"feedUrls": ["https://hnrss.org/frontpage"],
"mode": "monitor",
"stateKey": "weekly-hn",
"maxItemsPerFeed": 10,
"maxItemsTotal": 10,
"emitBaselineItems": true,
"emitUnchanged": false,
"emitNoLongerCurrent": false
}
Run again with the same input and storage to find changes. First run emits up to 10 NEW baseline rows; later runs emit only new or updated items unless you enable unchanged rows. The Actor does not create the schedule.
Output fields
Dataset rows have rowType: "ITEM" or rowType: "RUN_SUMMARY". Every row includes schemaVersion (integer 1), runId (string), observedAt (UTC ISO date-time), mode (snapshot/monitor) and status (item change or run status). Run statuses are COMPLETED, PARTIAL, TECHNICAL_ERROR, or INVALID_INPUT.
ITEM fields
| Field(s) | Type | Meaning and missing values |
|---|---|---|
feedIndex, itemIndex | integer | Input feed position and source item position, starting at 0 |
feedUrl, effectiveFeedUrl | string | Validated input feed and final URL after redirects |
feedType | enum | rss2, rss1-rdf, atom |
feedTitle | string or null | Feed title supplied by the source |
itemKey | string | Versioned item identity; stable under ordinary feed reorder |
identitySource, identityQuality | enums | sourceId / canonicalLink / synthetic; quality source / link / synthetic |
guid, link, title | string or null | Source ID, normalized feed-supplied link, and title; the link is never fetched |
authors, categories | string[] | Source names and topic labels, or empty arrays |
publishedAt, updatedAt | ISO string or null | Parsed publication and update dates; null if absent/unusable |
rawDateText | string or null | Original bounded date text for diagnosis |
summary, content | string or null | Feed-provided text; content is normally null until includeContent: true |
enclosures | object[] | Only metadata: url, type, length, title (each nullable); never downloaded |
fingerprint | string | Versioned item content fingerprint used for monitor comparison |
changeType, status | enum | SNAPSHOT, NEW, UPDATED, UNCHANGED, NO_LONGER_IN_CURRENT_FEED |
presentInCurrentFeed, deletionConfirmed | boolean | Presence in current window; deletion confirmation is always false |
contentTruncated, sourceConflict | boolean | Configured content limit reached; duplicate source identity had different content |
language, rights | string or null | Optional feed-level metadata when available |
If a source item has no date or title, the field is null, not invented. Empty author/category/enclosure arrays mean none were returned. Each item is bounded; XML/numeric references decode once; CDATA stays literal. Published v1 item keys are retained even when decoded display values correct a prior encoded value. Such a correction may appear once as UPDATED. HTML text may be normalized. Treat text fields as untrusted data in downstream systems.
RUN_SUMMARY fields
| Field(s) | Type | Meaning |
|---|---|---|
startedAt, finishedAt | ISO string | Run start and finish |
inputFeedCount | integer | Number of requested feeds |
feedResults | object[] | One result per input feed, including failures |
emittedItemRows, chargeableItemRows, chargedItemRows | integer | Saved item rows, eligible item charges, and acknowledged rss-item charges |
chargeStatus | enum | NOT_APPLICABLE, COMMITTED, LIMIT_REACHED, UNCERTAIN |
countsByChangeType | object | Counts of SNAPSHOT, NEW, UPDATED, UNCHANGED, NO_LONGER_IN_CURRENT_FEED |
duplicateCount, filteredCount | integer | Removed duplicate items and filtered items |
omittedCount, suppressedUnchangedCount | integer | Current-window omissions and skipped unchanged rows |
partial | boolean | At least one feed did not complete |
state | enum | NOT_USED, BASELINE_CREATED, COMMITTED, RETAINED_AFTER_FAILURE, RESET, CONFLICT, UNCERTAIN |
stateVersion | integer or null | Version of saved monitor state, when known |
validatorHits | integer | Count of 304 validator responses |
warnings | string[] | Bounded warnings and status notes |
errorCode | string or null | Canonical run-level error, when present |
Each feedResults object includes feedUrl (string), feedIndex (integer), outcome (string), httpStatus (integer or null), itemsSeen / itemsEmitted (integers), retries / requests (integers), wireBytes / decompressedBytes (integers), truncated (boolean), retryAfterSeconds (integer or null), and errorCode (string or null). Source timeouts, broken XML, blocked redirects, or source errors appear here rather than as fake article rows.
Real sample from the public HN RSS feed on 2026-10-09 at 08:15 UTC (trimmed fields; the source changes over time):
{
"schemaVersion": 1,
"rowType": "ITEM",
"mode": "snapshot",
"feedUrl": "https://hnrss.org/frontpage",
"feedType": "rss2",
"feedTitle": "Hacker News: Front Page",
"itemKey": "v1:sourceId:fc45d683916c42bc268704901045f040",
"title": "OTel-Native by Design – Building Products That Export to Any Observability Stack",
"link": "https://opentelemetry.io/blog/2026/otel-native-by-design/",
"publishedAt": "2026-10-09T06:54:45.000Z",
"changeType": "SNAPSHOT",
"presentInCurrentFeed": true,
"deletionConfirmed": false
}
This example was observed in a local production-container run. Its source text, title and date are not guaranteed to appear in future snapshots.
Output locations and special results
| Situation | Where to look | Meaning |
|---|---|---|
| Normal snapshot | Dataset or OUTPUT.results | ITEM rows followed by RUN_SUMMARY |
| Empty feed / no matched keywords | Final RUN_SUMMARY | emittedItemRows: 0 with per-feed outcome, filtering, and errors |
| Quiet monitor | Final RUN_SUMMARY | A valid baseline comparison can emit no ITEM rows |
| Source error / partial response | feedResults, partial, errorCode | Some items may still exist; inspect each feed before retrying |
| Invalid input | Final RUN_SUMMARY | status: "INVALID_INPUT"; correct field names and URLs |
| Changed monitor baseline | Named key-value store, RUN_SUMMARY.state | State is bounded and scoped; reuse the intended stateKey |
The default Dataset is available as rows, JSON, CSV, and other Dataset export formats. The Apify Output page exposes results, a link to the default Dataset items; it is a link, not an extra Dataset. The named key-value store holds versioned monitor state and coordination locks under RSSMON/v1/; do not edit its records manually. RUN_SUMMARY is saved even when item rows are absent. No raw feed XML, article HTML pages, images, or downloaded enclosure files are stored as output.
Pricing and cost examples
Applied public price checked 2026-10-09: PAY_PER_EVENT, $0.00075 for each saved ITEM or requested monitor status row (rss-item). The final RUN_SUMMARY is not charged as an item. The standard apify-actor-start event adds $0.0056 per allocated GB (minimum one event). Apify charges it automatically; the Actor does not charge a second start fee. Platform usage during the run is included in these event prices. Platform spending controls and available credits can change the buyer's invoice; always check the Actor's current Pricing tab before starting a paid run.
| Example (up to 1 GB) | Saved item rows | Total event charge |
|---|---|---|
| Small snapshot | 10 | $0.01310 |
| Larger snapshot | 100 | $0.08060 |
| Valid empty / fully filtered / quiet monitor | 0 | $0.00560 |
| Monitor with 3 new and 2 requested unchanged items | 5 | $0.00935 |
The last row and suppressed duplicates do not count as items. A partial run can still charge for the ITEM rows it saved. An empty/failed run still pays the standard start charge even if it has no item charge. At 2 GB it has two start events; at 4 GB it has four. The minimum allowed max-total-charge is $0.00635 (one 1-GB start plus one item). The maxItemsTotal input limits rows, not the entire possible cost of a run. Use Apify's max-total-charge setting to limit chargeable events, and check chargeStatus and charged counts in the last summary; a reached spending cap can stop item emission.
Limits and safe access
The Actor reads feed files via direct HTTP(S) calls with bounded requests, redirects, decompressed bytes, retries, item limits, and concurrency. It rejects URL credentials, private/reserved IP targets, unsupported ports, and unsafe redirects. XML DTD, external entities, and unsafe entity expansion are refused. Item links and enclosure URLs are returned as data only.
A publisher may change a feed, remove items from its rolling feed window, send invalid XML, rate-limit requests, or omit dates. This Actor cannot promise full source history, guaranteed availability, or continuous freshness. Use observedAt, feedResults, and partial to judge the result. Monitor windows are bounded and may reset or migrate when the state format changes.
Troubleshooting and FAQ
Why did I get only a summary? A feed may be empty, filters may match nothing, maxItemsTotal may be zero, or monitor mode may have no changed items. Read feedResults[*].outcome, errorCode, and countsByChangeType. Fix the input or try a public direct feed URL when a feed is blocked; an error is not proof of an empty source.
Why is the date null? The source did not provide a valid usable date for that entry. rawDateText may help. Sorting by publication date puts dated items first; a date filter may exclude undated items.
Can it scrape website pages or discover feeds? No. Supply exact public RSS/RDF/Atom URLs. includeContent includes only content delivered in the feed itself.
Is NO_LONGER_IN_CURRENT_FEED a deleted article? No. A rolling feed often stops showing older posts. The Actor always writes deletionConfirmed: false and avoids omission claims when the current source is incomplete.
How can I receive alerts or schedule the monitor? Create a separate Apify schedule or integration after you test the monitor state with your intended storage. The Actor itself sends no alerts, creates no schedules and runs no webhooks.
Why are the input form and API defaults different? The new form shows a small 10/10 demo. The API without those optional limits uses 50/1000. The required feedUrls must always be supplied to an API run.
How do I report a source failure? Keep the run ID and non-sensitive feedResults error code. Do not post API tokens, cookies, private feed addresses or personal data.
Support
Use the Issues tab on the Actor Store page for problems or questions. Include the run ID, public feed format, the mode, and the error code from RUN_SUMMARY. Redact private information. See the Input and Output tables above for the full public field reference.
Changelog
This Actor's version history is a separate document: https://apify.com/cliqtomedia/rss-atom-feed-reader-monitor/changelog.md
Actor input Schema
feedUrls (type: array):
Direct public HTTP(S) feed URLs. Homepages, login details and private network addresses are rejected.
mode (type: string):
Read current items or compare with the previous monitor run.
maxItemsPerFeed (type: integer):
Stop after this many items from each feed.
maxItemsTotal (type: integer):
Stop after this many saved item rows in one run.
sort (type: string):
Keep feed order or show newer published items first.
publishedAfter (type: string):
Keep items published at or after this UTC time.
publishedBefore (type: string):
Keep items published before this UTC time.
includeKeywords (type: array):
Keep items whose title, summary or feed content contains these words.
excludeKeywords (type: array):
Skip items whose title, summary or feed content contains these words.
dedupeAcrossFeeds (type: boolean):
Keep the first copy when the same item appears in more than one feed.
includeContent (type: boolean):
Save content supplied by the feed. The Actor does not open item links.
maxSummaryChars (type: integer):
Limit the saved feed summary to this many characters.
maxContentChars (type: integer):
Limit the saved feed content to this many characters.
requestTimeoutMs (type: integer):
Stop waiting for one feed after this many milliseconds.
maxRetries (type: integer):
Retry a temporary feed problem this many times.
maxConcurrency (type: integer):
Read no more than this many feeds at the same time.
stateKey (type: string):
Name a monitor so separate jobs use separate saved state.
resetState (type: boolean):
Forget the selected monitor baseline before this run.
emitBaselineItems (type: boolean):
In monitor mode, show the first baseline items as NEW rows.
emitUnchanged (type: boolean):
In monitor mode, also show items that did not change. Each saved unchanged item is charged like any other saved item.
emitNoLongerCurrent (type: boolean):
Show items missing from the current feed window. This does not mean they were deleted.
Actor input object example
{
"feedUrls": [
"https://hnrss.org/frontpage"
],
"mode": "snapshot",
"maxItemsPerFeed": 10,
"maxItemsTotal": 10,
"sort": "source",
"publishedAfter": null,
"publishedBefore": null,
"includeKeywords": [],
"excludeKeywords": [],
"dedupeAcrossFeeds": false,
"includeContent": false,
"maxSummaryChars": 4000,
"maxContentChars": 20000,
"requestTimeoutMs": 15000,
"maxRetries": 2,
"maxConcurrency": 5,
"stateKey": null,
"resetState": false,
"emitBaselineItems": false,
"emitUnchanged": false,
"emitNoLongerCurrent": false
}
Actor output Schema
results (type: string):
Open the saved item rows and final run summary.
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
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 = {
"feedUrls": [
"https://hnrss.org/frontpage"
],
"maxItemsPerFeed": 10,
"maxItemsTotal": 10
};
// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/rss-atom-feed-reader-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
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 = {
"feedUrls": ["https://hnrss.org/frontpage"],
"maxItemsPerFeed": 10,
"maxItemsTotal": 10,
}
# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/rss-atom-feed-reader-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
echo '{
"feedUrls": [
"https://hnrss.org/frontpage"
],
"maxItemsPerFeed": 10,
"maxItemsTotal": 10
}' |
apify call cliqtomedia/rss-atom-feed-reader-monitor --silent --output-dataset
MCP server setup
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/rss-atom-feed-reader-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/naprVLGbTcnbs7b53/builds/30dsfkiPQb4AdEJBW/openapi.json