# Telecom & Wireless Papers Monitor (arXiv) (`simonzhong/telecom-papers-monitor`) Actor

Monitor new arXiv papers in wireless, telecom, signal processing and networking. Filter by category, keyword and date; get clean, deduplicated records with only new papers each run.

- **URL**: https://apify.com/simonzhong/telecom-papers-monitor.md
- **Developed by:** [Simon Zhong](https://apify.com/simonzhong) (community)
- **Categories:** AI, News, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 paper records

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

## Telecom & Wireless Papers Monitor (arXiv)

Get a clean, structured, **deduplicated** feed of new public research papers in wireless communications,
signal processing, networking, information theory and systems — straight from the **official arXiv API**.
Run it once for a literature snapshot, or schedule it daily or weekly to get **only the papers you haven't seen yet**.

### Use cases

- **R\&D and standards teams**: a weekly digest of new papers on topics you track (CSI feedback, ISAC, RIS, O-RAN, 6G).
- **Literature reviews**: export every paper in a category and date range to JSON, CSV or Excel in one run.
- **AI / RAG pipelines**: clean title + abstract + metadata records, ready to embed or feed to an LLM.
- **Alerts**: schedule the Actor and connect it to Slack, email, Google Sheets or webhooks with Apify integrations.

### What it does

- Searches arXiv by **category** (default `cs.IT`, `eess.SP`, `cs.NI`, `eess.SY`) and optional **keywords**
  (e.g. `massive MIMO`, `CSI feedback`, `O-RAN`, `ISAC`, `6G`) with AND/OR logic.
- **Primary category only** (on by default): keeps papers whose *main* category is one you selected, dropping
  papers that are only cross-listed into it (e.g. robotics papers cross-listed to `eess.SY`).
- Filters by a **date window** (last N days, or from/to dates).
- Outputs one tidy JSON record per paper: arXiv ID, version, title, authors, abstract, categories, dates, PDF and
  abstract links, DOI, journal reference, comments.
- **Monitoring mode**: remembers seen arXiv IDs in a named key-value store, so scheduled runs output (and bill)
  only new papers. Optionally treats new versions (v2, v3…) as new.
- Polite by design: official API only, ≥3 s between requests, paginated, identifying User-Agent, following the
  [arXiv API Terms of Use](https://info.arxiv.org/help/api/tou.html). Only public metadata is collected; PDFs are not downloaded.

### How to use

1. Pick your **categories** (the defaults cover wireless/telecom) and optionally add **keywords**.
2. Set the date window (**Last N days**) and **Max records**.
3. Click **Start**. Results appear in the **Output** tab and can be downloaded as JSON, CSV, Excel or via API.
4. For monitoring, tick **Only output papers not seen in previous runs** and add a **Schedule** (e.g. daily).

### Input

| Field | Default | Description |
|---|---|---|
| `categories` | `["cs.IT","eess.SP","cs.NI","eess.SY"]` | arXiv categories, OR-ed. `cs.LG` is very large; add it together with keywords (e.g. `wireless`, `MIMO`, `channel`) |
| `primaryCategoryOnly` | `true` | Keep only papers whose primary category is selected (aliases like `cs.IT`/`math.IT`, `eess.SY`/`cs.SY` count). Filtered papers are not output, not charged and not remembered |
| `keywords` | `[]` | Optional phrases matched in title/abstract |
| `keywordsOperator` | `OR` | `OR` = any keyword, `AND` = all keywords |
| `keywordFields` | `title_abstract` | `title_abstract`, `title`, or `all` |
| `lastNDays` | `7` | Date window; ignored if `dateFrom`/`dateTo` set; `0` = no date filter |
| `dateFrom` / `dateTo` | – | `YYYY-MM-DD` (UTC, inclusive) |
| `dateField` | `submittedDate` | or `lastUpdatedDate` |
| `maxRecords` | `100` | Max papers output (and charged) per run |
| `sortBy` / `sortOrder` | `submittedDate` / `descending` | also `lastUpdatedDate`, `relevance` |
| `onlyNew` | `false` | Skip papers seen in previous runs (free) |
| `includeNewVersions` | `false` | With `onlyNew`, output a paper again when a higher version appears |
| `seenStoreName` | `telecom-papers-seen` | Named key-value store for seen IDs; use a different name per monitor |
| `maxScannedRecords` | `2000` | With `onlyNew`/`primaryCategoryOnly`, cap on arXiv results scanned |
| `contactEmail` | – | Optional override of the contact in the User-Agent sent to arXiv |

Example: a weekly monitor for AI-native air-interface papers.

```json
{
  "categories": ["cs.IT", "eess.SP", "cs.NI"],
  "keywords": ["CSI feedback", "AI-native", "neural receiver", "beam management"],
  "keywordsOperator": "OR",
  "lastNDays": 8,
  "maxRecords": 500,
  "onlyNew": true,
  "seenStoreName": "ai-air-interface-monitor"
}
```

### Output example

```json
{
  "source": "arxiv",
  "arxiv_id": "2610.37424",
  "version": 1,
  "title": "Privacy-Preserving Over-the-Air Federated Learning over Cell-Free Massive MIMO System with User-Centric Clustering",
  "authors": [{"name": "Manobendu Sarker", "affiliations": []}, {"name": "Soumaya Cherkaoui", "affiliations": []}],
  "abstract": "This paper investigates cross-layer design for differentially private federated learning over cell-free massive MIMO networks ...",
  "categories": ["cs.IT", "eess.SY"],
  "primary_category": "cs.IT",
  "published": "2026-10-27T15:37:21Z",
  "updated": "2026-10-27T15:37:21Z",
  "pdf_url": "https://arxiv.org/pdf/2610.37424v1",
  "abs_url": "https://arxiv.org/abs/2610.37424v1",
  "doi": null,
  "journal_ref": null,
  "comments": null,
  "topics": null, "tasks": null, "methods": null, "datasets": null, "metrics": null,
  "llm_enriched": false,
  "is_new": true
}
```

`topics`, `tasks`, `methods`, `datasets`, `metrics` and `llm_enriched` are reserved for a possible future version and
are always `null` / `false` in this version. Each run also saves a `RUN_SUMMARY` record (output/scanned/skipped counts,
stop reason, the exact arXiv query) to its default key-value store.

### Pricing

**$2 per 1,000 papers** ($0.002 per output paper, event `paper-record`).
Papers skipped as already seen, or filtered out by *Primary category only*, are **free**. The run stops cleanly at your
maximum charge limit, so you never pay more than you set. Example: a daily monitor that outputs ~40 new papers costs
about $0.08 per run.

### Tips

- arXiv announces new submissions with a delay (typically ~1 business day, none on weekends), so the most recent
  day of a window is usually still empty. For daily schedules use `lastNDays` ≥ 3 with `onlyNew` on. The overlap
  costs nothing because already-seen papers are not charged.
- Typical volume (checked Oct 2026, default categories, 7 days): ~385 papers incl. cross-lists, ~272 with
  *Primary category only*. `cs.IT` alone ≈ 137/week incl. cross-lists.
- Each arXiv page (≤100 papers) takes ≥3 s because of the rate limit, so 1,000 papers take about 30 s or more.
- Abstracts may contain LaTeX (`$...$`); it is passed through unchanged.
- Known limitation: an *old* paper newly cross-listed into a category keeps its original submission date, so a
  date-window search doesn't catch it (≈1 in 137 in our check).

### FAQ

**Is this allowed?** Yes. The Actor uses arXiv's official, public API within its published rate limits and only
collects public metadata (titles, abstracts, authors, links). It does not download PDFs.

**Why are there fewer papers than in the category listing?** By default, *Primary category only* drops papers that
are only cross-listed into your categories. Turn it off to include them.

**Can I run several monitors?** Yes. Give each one its own `seenStoreName` so their "seen" lists don't mix.

### Roadmap (planned, not available yet)

- IETF drafts/RFCs and 3GPP specification metadata (metadata, abstract and links only).
- Optional AI structuring of papers into the reserved fields above.

### Data & attribution

Metadata is retrieved from the arXiv API. Thank you to arXiv for use of its open access interoperability.
Paper content remains under each paper's own license; this Actor does not download or redistribute PDFs.

# Actor input Schema

## `categories` (type: `array`):

arXiv category codes (OR-ed). Defaults cover information theory, signal processing, networking and systems/control. Other useful ones: cs.AI, eess.AS, cs.LG (cs.LG is very large and broad: best combined with keywords such as "wireless" or "MIMO"). Note: math.IT = cs.IT and cs.SY = eess.SY are aliases.

## `primaryCategoryOnly` (type: `boolean`):

Keep only papers whose primary (main) arXiv category is one of the selected categories (aliases such as cs.IT/math.IT and eess.SY/cs.SY count). Recommended: cross-lists into broad categories like eess.SY bring in many robotics/control/logic papers. Turn off to also include papers merely cross-listed into your categories. Filtered papers are not output, not charged and not remembered as seen.

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

Optional phrases matched in title/abstract, e.g. "massive MIMO", "CSI feedback", "6G", "O-RAN". Leave empty to get everything in the categories.

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

How multiple keywords are combined. Categories are always AND-ed with the keyword clause.

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

Where keywords are matched: title + abstract (recommended), title only, or all fields (also authors, comments, journal ref).

## `lastNDays` (type: `integer`):

Only papers in the last N days (UTC). Ignored if Date from / Date to is set. 0 = no date filter.

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

Optional explicit window start (UTC, inclusive). Overrides Last N days.

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

Optional explicit window end (UTC, inclusive). Defaults to now.

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

Which date the window applies to: first submission (recommended for new-paper monitoring) or last update.

## `maxRecords` (type: `integer`):

Maximum number of papers to output in this run. Each output paper is one paper-record event ($0.002, i.e. $2 per 1,000). Papers skipped as already seen are free.

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

Sort order of arXiv results. Use submittedDate for monitoring; relevance is useful for one-off keyword searches.

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

Descending returns the newest first.

## `onlyNew` (type: `boolean`):

Monitoring mode: skip papers already stored in the 'seen IDs' key-value store. Skipped papers are not charged. Use with a schedule.

## `includeNewVersions` (type: `boolean`):

With 'Only new', re-output a paper when a higher version appears.

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

Named key-value store that keeps seen arXiv IDs across runs. Use different names for independent monitors. Empty = do not persist.

## `maxScannedRecords` (type: `integer`):

When 'Only new' or 'Primary category only' is on, upper bound of arXiv results scanned to find enough matching papers (each page of 100 takes ≥3 s due to arXiv rate limits).

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

Replaces the maintainer contact in the User-Agent sent to arXiv (arXiv asks API clients to identify themselves). Leave empty to use the default.

## Actor input object example

```json
{
  "categories": [
    "cs.IT",
    "eess.SP",
    "cs.NI",
    "eess.SY"
  ],
  "primaryCategoryOnly": true,
  "keywords": [],
  "keywordsOperator": "OR",
  "keywordFields": "title_abstract",
  "lastNDays": 7,
  "dateField": "submittedDate",
  "maxRecords": 100,
  "sortBy": "submittedDate",
  "sortOrder": "descending",
  "onlyNew": false,
  "includeNewVersions": false,
  "seenStoreName": "telecom-papers-seen",
  "maxScannedRecords": 2000
}
```

# Actor output Schema

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

All paper records from this run (arXiv ID, title, authors, abstract, categories, dates, links).

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

JSON summary of the run: counts of fetched, filtered, skipped (already seen) and output 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 = {
    "categories": [
        "cs.IT",
        "eess.SP",
        "cs.NI",
        "eess.SY"
    ],
    "keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("simonzhong/telecom-papers-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 = {
    "categories": [
        "cs.IT",
        "eess.SP",
        "cs.NI",
        "eess.SY",
    ],
    "keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("simonzhong/telecom-papers-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 '{
  "categories": [
    "cs.IT",
    "eess.SP",
    "cs.NI",
    "eess.SY"
  ],
  "keywords": []
}' |
apify call simonzhong/telecom-papers-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simonzhong/telecom-papers-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/RmTMLJbU3GlTrSChd/builds/38Jo1yQHZTf92m8iQ/openapi.json