# Software Lifecycle Watchlist Monitor (`maydit/software-lifecycle-watchlist-monitor`) Actor

Monitor exact software release cycles, published support deadlines and saved date revisions. Export lifecycle evidence for upgrade planning without scanning systems or inferring compliance.

- **URL**: https://apify.com/maydit/software-lifecycle-watchlist-monitor.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 software lifecycle observations

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

![Software Lifecycle Watchlist Monitor — illustrative watchlist workflow](https://api.apify.com/v2/key-value-stores/cCyrofyNNh9lwffXB/records/software-lifecycle-watchlist-monitor-3eeccb2c9687.png?signature=1KYSxONeoTjrUBTAGIq58)

### Turn release support dates into a reviewable inventory

Keep an exact list of software release cycles and their published support deadlines. Export community-maintained endoflife.date declarations, calculated UTC deadline windows and saved date revisions for an upgrade-planning queue.

**One result is one product/release-cycle observation.** The Actor does not inspect systems or discover installed versions. Source declarations remain separate from calculated countdowns.

[First run](#try-a-small-watchlist) · [Output preview](#output-preview) · [Saved comparisons](#save-a-comparison-baseline) · [Pricing](#pricing)

### Try a small watchlist

Paste this exact input into Console's JSON editor. No source API key is required. These historical examples demonstrate the fields; they are not recommendations to install these versions.

```json
{
  "watchlist": [
    {
      "product": "nodejs",
      "cycle": "22"
    },
    {
      "product": "python",
      "cycle": "3.10"
    }
  ],
  "maxResults": 5
}
```

Open **Dataset** for saved observations and **Run report** for coverage. **SUMMARY** is the machine-readable record. Empty API input and the Console prefill use the documented sample inventory; the maximum is a cap, not a promised result count.

### Output preview

| Planning question | Fields | Interpretation |
| --- | --- | --- |
| Which release? | `observationId`, `product`, `cycle` | Exact requested inventory identity |
| What deadlines are published? | `activeSupportEnds`, `endOfLifeDate`, `extendedSupportEnds`, `labels` | Distinct source support phases; null means no date was supplied |
| Is it approaching a deadline? | `asOfDate`, `daysToEndOfLife`, `deadlineWindow` | UTC date calculation, not a vendor promise or risk score |
| What does the source report? | `isEoas`, `isEol`, `isEoes`, `isMaintained`, `isLts` | Nullable source flags, not inferred from missing dates |
| Did the deadline move? | `endOfLifeDateShiftDays`, `activeSupportDateShiftDays` | Positive means the saved date moved later; null means no two dated observations |
| Where is the evidence? | `vendorPolicyUrl`, `sourceUrl`, `sourceLastModifiedAt`, `observedAt` | Vendor policy link, community source and retrieval time |

Latest release metadata is available in `latest`. The snapshot includes source dates, flags, labels and latest release metadata. `daysToEndOfLife`, `deadlineWindow`, observation time and source generation timestamps are excluded from comparisons: the passage of one day alone does not create a source-change event. Use `onlyChanges: false` and filter the deadline fields downstream for approaching-deadline reminders.

### Inspect a second inventory

Inspect Ubuntu 22.04 and 24.04 support declarations with distinct standard and extended-support dates.

```json
{
  "watchlist": [
    {
      "product": "ubuntu",
      "cycle": "22.04"
    },
    {
      "product": "ubuntu",
      "cycle": "24.04"
    }
  ],
  "maxResults": 5
}
```

### Save a comparison baseline

Record Node.js 22 once, then compare future published support dates and latest-release metadata against saved values.

```json
{
  "watchlist": [
    {
      "product": "nodejs",
      "cycle": "22"
    }
  ],
  "comparePrevious": true,
  "snapshotName": "node22-lifecycle-review",
  "maxResults": 5
}
```

1. Run once to save `new` observations.
2. Repeat with the same inventory, `snapshotName` and named history store. Rows become `changed` or `unchanged`, with `previous`, `previousObservedAt` and `changedFields`.
3. Add `onlyChanges: true` to suppress unchanged source observations. This also enables comparison. A healthy repeat can save zero rows.
4. In Sheets, Make or n8n, wait for completion, check SUMMARY, then upsert by `observationId`. Keep the run ID for replay and deduplicate deliveries with `observationId + contentHash`.

The versioned history scope contains the exact sorted inventory and namespace. Changing that inventory starts a separate comparison. Only confirmed dataset writes advance history. Errors, unsaved capped rows and unchanged skips preserve prior observations; missing sources never imply deletion. Use **one writer per scope**: a pre-commit check detects existing concurrent changes, but is not an atomic lock. The named store holds at most 20,000 saved identities per scope.

The Actor supplies observations and a report. You configure schedules, alerts and downstream accounts. A history failure can leave valid saved rows; inspect `historyUpdated` and `failedSources.history`. Comparisons cover last saved observations, not every upstream change between runs.

### Coverage and interpretation

- **Exact inventory:** up to 50 product/cycle entries. No URL crawling, patch-version inference, installed inventory scan or all-product enumeration. Missing cycles fail explicitly; they never become fictitious lifecycle rows.
- **Source scope:** endoflife.date is community-maintained and its API is documented as beta. Verify important dates with the linked vendor policy; extended-support dates do not imply you have a paid support entitlement.
- **Date meaning:** all displayed date-only values are source dates. Countdown windows use the observation's UTC date. Unknown dates remain null; source flags remain separate and may use product-specific labels.
- **Useful corrections:** only source observation fields trigger saved changes. Daily countdowns remain available in ordinary repeated rows.
- **Access and budgets:** public documented APIs only, sequential requests, pinned public DNS and no cross-host redirect following. Responses are capped at 2 MiB. One bounded retry is allowed for 502/503/504; rate/access refusals are reported without bypass.
- **Run bounds:** `maxRunSeconds` defaults to 240 and also respects the platform deadline minus 25 seconds. Configure Apify's maximum total charge as well as `maxResults`.

SUMMARY includes saved/observed counts, per-source coverage, unreached entries, history outcome and time/spending limits. Intentional output caps are bounded samples. Source, source-window, time and history failures are partial or failed. All-source or all-output failures fail the run. Errors and no-match diagnostics are never paid data rows.

### Pricing

Base FREE-tier rate: **$2 per 1,000 saved observations**, plus the listed **Actor Start** charge. The [Pricing tab](https://apify.com/maydit/software-lifecycle-watchlist-monitor/pricing) is authoritative for your plan. Saved unchanged observations are billable; unchanged rows suppressed by `onlyChanges` have no dataset-item charge. Platform and storage charges may apply under your plan.

### Sources and support

[API v1 documentation](https://endoflife.date/docs/api/v1/) · [Project and API status](https://github.com/endoflife-date/endoflife.date) · [MIT license](https://github.com/endoflife-date/endoflife.date/blob/master/LICENSE)

Lifecycle data is attributed to endoflife.date contributors. The source license notice is included in LICENSE-SOURCES.txt. Product descriptions and third-party logos are not copied. This community Actor is not affiliated with endoflife.date or the software vendors.

For help, open **Issues** with the run URL and expected public field, or contact **bmay@mayd-it.com**. Remove credentials and private inventory information before posting.

# Actor input Schema

## `watchlist` (type: `array`):

Up to 50 objects with exact product and cycle strings. Product slugs and cycle names come from endoflife.date. Omitted or empty uses Node.js 22, Python 3.10 and Ubuntu 22.04. Patch versions, URLs and automatic installed-version discovery are not supported.

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

Caps confirmed dataset rows, including saved unchanged observations. A limit is a sample, not a complete inventory; inspect sourceCoverage and sourcesNotReached in SUMMARY.

## `comparePrevious` (type: `boolean`):

First observations are new. Later rows include changed/unchanged status, prior saved values and changedFields. Only confirmed saved rows advance history.

## `onlyChanges` (type: `boolean`):

Implies comparison. Rolling countdowns and deadline windows do not trigger changes. Leave false to export daily approaching-deadline observations.

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

1-80 letters, numbers, underscores or hyphens. History also includes the exact sorted inventory. Use one writer per scope; changing the inventory starts a separate baseline.

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

3-63 letters, numbers or hyphens. Accessed only for comparisons. Use a dedicated store for each customer workflow.

## `maxRunSeconds` (type: `integer`):

Includes source and comparison work; also bounded by the platform deadline minus 25 seconds. Each response is capped to 2 MiB. Access and rate refusals are reported.

## Actor input object example

```json
{
  "watchlist": [
    {
      "product": "nodejs",
      "cycle": "22"
    },
    {
      "product": "python",
      "cycle": "3.10"
    },
    {
      "product": "ubuntu",
      "cycle": "22.04"
    }
  ],
  "maxResults": 5,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "stateStoreName": "maydit-software-lifecycle-watchlists",
  "maxRunSeconds": 240
}
```

# Actor output Schema

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

Source-backed observations only. Errors and empty-match diagnostics never become paid dataset rows.

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

Readable coverage, limits and saved-history outcome.

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

Saved counts, source coverage, incomplete checks, failed sources and stop flags.

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

Download saved observations for a spreadsheet; JSON retains nested evidence.

# 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 = {
    "watchlist": [
        {
            "product": "nodejs",
            "cycle": "22"
        },
        {
            "product": "python",
            "cycle": "3.10"
        },
        {
            "product": "ubuntu",
            "cycle": "22.04"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/software-lifecycle-watchlist-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 = { "watchlist": [
        {
            "product": "nodejs",
            "cycle": "22",
        },
        {
            "product": "python",
            "cycle": "3.10",
        },
        {
            "product": "ubuntu",
            "cycle": "22.04",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maydit/software-lifecycle-watchlist-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 '{
  "watchlist": [
    {
      "product": "nodejs",
      "cycle": "22"
    },
    {
      "product": "python",
      "cycle": "3.10"
    },
    {
      "product": "ubuntu",
      "cycle": "22.04"
    }
  ]
}' |
apify call maydit/software-lifecycle-watchlist-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maydit/software-lifecycle-watchlist-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/qqPduGtKLZi4Ylu6b/builds/5WqRvYEFrZZA8h0CP/openapi.json