# Software End-of-Life Checker for Your Version List > Software end of life checker with endoflife.date data: support phase, EOL and extended support dates, LTS and latest patch for your versions. URL: https://cliqtomedia.com/actors/software-end-of-life-checker/ Category: Developer & website monitoring · Status: live on Apify Store · Apify page: https://apify.com/cliqtomedia/software-end-of-life-checker?fpr=cliqto Add rows like nodejs 18.20.4 or ubuntu 20.04, or a CSV. For each version you see its support phase and EOL dates. A flag shows what ends soon. ## How to use it: 3 steps 1. **Make a free Apify account.** Apify is the cloud platform where our tools run. The free plan gives you $5 of usage every month, no credit card needed. You pay Apify, not us. 2. **Paste your input and press Start.** No code needed: you fill in a form (the input). It already has a working example. For example: `nodejs 18` in Software (product + version). Each start is one run. 3. **Download the results.** When the run ends, the results are in a table (the dataset). Open Output, press Export and pick Excel or CSV. JSON and the API are there too. ## What it does Software End-of-Life Checker checks your software versions against [endoflife.date](https://endoflife.date). Add product + version rows such as `nodejs 18.20.4`, `python 3.8` or `ubuntu 20.04`, or a CSV. You get one row per version with the matched release cycle, the support phase on a date (active, security-only, extended, EOL), the end of active support, end of life (EOL) and end of extended support dates, LTS status, the latest patch and a near-EOL flag. - Finds the product. It accepts endoflife.date names (`nodejs`), their aliases and common spellings (`node`, `postgres`, `golang`, `Node.js`). An unknown name gives an `unknown_product` row with suggestions. It is never guessed. - Finds the release cycle. A cycle (`18`), a minor version (`3.8`) or a full patch (`18.20.4`, `v18.20.4`) all work. Codenames (`focal`) and release names (SQL Server `2019`) work too. If a version fits several cycles (for example `python 3`), you get an `ambiguous_version` row with the candidates. - Computes the support phase on the as-of date (today by default) and the days left to each date. - Explains the match in `matchExplanation`, for example `product "node" → nodejs (alias); version "18.20.4" → cycle 18 (prefix match)`. ### Good for - Find which of your runtimes, databases and operating systems are already EOL or end soon. - Plan upgrades for next quarter with `asOfDate`. - Add lifecycle dates to an SBOM, CMDB or asset list (CSV in, rows out). - Run a regular check of a fixed list and keep only rows that need action (`onlyAttention`). ### Not a good fit - Vulnerability (CVE) scanning or a security audit. The Actor reports published lifecycle dates only. - Products that endoflife.date does not track. They get an honest `unknown_product` row. - Vendor contracts. Paid extended support (for example Ubuntu Pro or a commercial Node.js offer) is shown as `extended`, but the Actor cannot know whether you have it. ## Price Pay per event. Apify bills you, not us. | What you pay for | Price | When | |---|---|---| | Start fee | $0.003 | Charged once per run. This tool uses 1 GB of memory or less by default; more memory costs more. | | Checked version | $0.0019 (from $0.0016 on paid Apify plans) | One input row matched to an endoflife.date product and release cycle and saved to the Dataset with its support phase and dates. | | Unmatched row | $0.0002 | One input row saved to the Dataset that could not be matched: unknown product, unknown or ambiguous version, or an invalid row. Source errors are not charged. | - One version: about $0.0049. - 1,000 versions: about $1.90. - Every day 100 versions, for 30 days: about $5.79 a month. Free to try: the Apify free plan gives you $5 of usage every month, no credit card needed. Prices checked on 24 October 2026. Current price: https://apify.com/cliqtomedia/software-end-of-life-checker?fpr=cliqto ## Questions ### Is it a vulnerability scanner? No. It shows published lifecycle dates only. Use our OSV scanner for CVEs. ### Why does Node.js 18 say extended? Some vendors offer paid extended support. The tool cannot know if you have it. ### What if my product is not found? You get an unknown_product row. It only covers products on endoflife.date. ### How many rows can I check? Up to 500 unique rows per run. ### How fresh is the data? Each run reads endoflife.date live. Each row has `sourceLastModified` (when the source last changed the product; `null` when the run used the full catalog, which has no per-product time) and `fetchedAt` (our read time). ### Can I check a future date? Yes. Set `asOfDate`. Dates in the past work too. The `isLts` value and the phase are computed for that date. ## Data fields - `input` (object): Your row as given: index (1-based), source (items, csvText or csvUrl), product, version and the raw text. - `status` (string): Row result. complete = product and cycle found; not_found = unknown product, unknown or ambiguous version; error = invalid row or endoflife.date failure (not the same as 'no data'). - `matchStatus` (string): Detailed match outcome. - `matchExplanation` (string): How your product and version were matched, e.g. product "node" → nodejs (alias); version "18.20.4" → cycle 18 (prefix match). - `needsAttention` (boolean): true when the cycle is not in active support (security-only, extended, eol, unknown), is near EOL, or the row could not be checked. - `product` (string): Canonical endoflife.date product slug, e.g. nodejs. - `productLabel` (string): Product name, e.g. Node.js. - `productCategory` (string): endoflife.date category, e.g. lang, framework, database, os. - `cycle` (string): Matched release cycle, e.g. 18, 3.8, 20.04. - `cycleLabel` (string): Cycle label from endoflife.date, e.g. 20.04 'Focal Fossa' (LTS). - `codename` (string): Cycle codename, if any. - `releaseDate` (string): First release date of the cycle (YYYY-MM-DD). - `isLts` (boolean): Long-term support cycle on the as-of date (uses ltsFrom when known). - `ltsFrom` (string): Date the cycle becomes or became LTS, if published. - `eoasFrom` (string): End of active support (bug fixes); after it only security fixes. null = the product has no such phase or the date is unknown. - `eolFrom` (string): End of standard support (end of life, no more security fixes). null = unknown, not 'supported forever'. - `eoesFrom` (string): End of extended (usually paid) support, e.g. Ubuntu ESM. Extended support is not standard support. - `hasExtendedSupport` (boolean): true when the cycle has an extended (paid) support phase. - `isEol` (boolean): true when standard support (security fixes from the vendor's standard policy) has ended on the as-of date — also during paid extended support. null when unknown. - `supportPhase` (string): Support phase on the as-of date: upcoming (not released yet), active, security-only, extended (standard EOL passed, paid extended support still running), eol, or unknown (dates not published). - `daysToEoas` (integer): Days from the as-of date to end of active support; negative = already passed. - `daysToEol` (integer): Days from the as-of date to EOL; negative = already passed. - `daysToEoes` (integer): Days from the as-of date to end of extended support; negative = already passed. - `nearEol` (boolean): true when the cycle is still supported and EOL is within nearEolDays; null when the EOL date is unknown. - `eolDateKnown` (boolean): false when endoflife.date has no EOL date for this cycle. - `latestPatch` (string): Latest release in this cycle, e.g. 18.20.8. - `latestPatchDate` (string): Date of the latest release. - `latestPatchUrl` (string): Release notes / changelog link of the latest release. - `isLatestPatch` (boolean): true/false when you gave a full version comparable with latestPatch; null otherwise. - `asOfDate` (string): Date the phase and day counts were computed for (YYYY-MM-DD). - `sourceUrl` (string): endoflife.date page of the product. - `apiUrl` (string): endoflife.date API endpoint used for the product. - `sourceLastModified` (string): When endoflife.date last changed this product's data. - `fetchedAt` (string): When this run fetched the product data. - `error` (string): Short reason for not_found and error rows; null when complete. - `suggestions` (array): Unknown product: close endoflife.date slugs. Unknown or ambiguous version: available cycles. ## Input settings - `items` (array): One row per line: product and version separated by a space or @, e.g. nodejs 18.20.4, python@3.8, postgres 12. Product names use endoflife.date slugs or common aliases (node, postgres, golang). Versions can be a cycle (18), a minor (3.8) or a full patch (18.20.4). Via API you can also pass objects {"product": "nodejs", "version": "18"}. Duplicates are checked once. - `csvText` (string): Paste a CSV with product and version columns (header optional; recognized headers: product/software/name and version/release/cycle). Comma, semicolon or tab. Max 200 KB. Combined with the list above. - `csvUrl` (string): Public https:// link to a CSV with the same columns (max 1 MB). Private and local network addresses are refused. - `nearEolDays` (integer): A still-supported cycle is flagged nearEol when its EOL date is within this many days of the as-of date. - `asOfDate` (string): Compute phases for this date (YYYY-MM-DD) instead of today, e.g. to plan upgrades for next quarter. - `timeZone` (string): IANA time zone that defines "today" when no as-of date is set, e.g. Europe/Berlin. Default UTC. - `onlyAttention` (boolean): Output only rows that need action: eol, extended, security-only, near EOL, unknown phase, not found or error. You pay only for rows that are output. ## Step by step on Apify 1. Open the Input tab. The form already has five versions: `nodejs 18`, `python 3.8`, `postgresql 12`, `ubuntu 20.04` and `angular 15`. 2. Click Start. 3. Open the Overview view in the Output tab. Check `supportPhase`, `eolFrom` and `daysToEol`. 4. Replace the list with your own versions (up to 500 rows), or paste a CSV into CSV text. ## Use cases | Task | Input | Key fields | |---|---|---| | Find EOL software in an inventory | `items` or `csvText` | `supportPhase`, `isEol`, `eolFrom`, `needsAttention` | | Plan upgrades before a date | `items` + `asOfDate` | `supportPhase`, `daysToEol`, `nearEol` | | Keep patch levels current | `items` with full versions | `latestPatch`, `isLatestPatch`, `latestPatchDate` | | Short action list for a team | `items` + `onlyAttention` | rows with `needsAttention: true` only | ## Tips - Set a future as-of date to see what will be EOL next quarter. - Turn on only attention rows to get a short action list. - Common names like node or postgres work. Unknown names get suggestions. ## Limits - Up to 500 unique rows per run. A larger input is refused. - Up to 10 distinct products: one request per product, at most 4 at a time and at least 150 ms apart. More than 10: one request for the full endoflife.date catalog (about 3 MB) instead. - Internal time budget is 240 seconds. Rows not reached in time get `error` rows and the run is `CAPPED`. - If endoflife.date fails for 2 products in a row, the Actor stops sending requests. Rows already tried get `source_error` rows; the rest are not written. `RUN_SUMMARY` counts them, so run again later. - The data is only as complete as endoflife.date. Some products have no EOL or extended support dates. ## Sample result ```json { "input": { "index": 4, "source": "items", "product": "ubuntu", "version": "20.04", "raw": "ubuntu 20.04" }, "status": "complete", "matchStatus": "matched", "matchExplanation": "product \"ubuntu\" → ubuntu; version \"20.04\" → cycle 20.04 (exact match)", "needsAttention": true, "product": "ubuntu", "productLabel": "Ubuntu", "productCategory": "os", "cycle": "20.04", "cycleLabel": "20.04 'Focal Fossa' (LTS)", "codename": "Focal Fossa", "releaseDate": "2020-04-23", "isLts": true, "eoasFrom": "2022-10-01", "eolFrom": "2025-05-31", "eoesFrom": "2030-04-23", "hasExtendedSupport": true, "isEol": true, "supportPhase": "extended", "daysToEol": -499, "daysToEoes": 1289, "nearEol": false, "latestPatch": "20.04.6", "latestPatchDate": "2023-03-23", "isLatestPatch": null, "asOfDate": "2026-10-12", "sourceUrl": "https://endoflife.date/ubuntu", "apiUrl": "https://endoflife.date/api/v1/products/ubuntu", "fetchedAt": "2026-10-12T08:20:20.391Z" } ``` ## Use it from code Actor ID: `cliqtomedia/software-end-of-life-checker` ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("cliqtomedia/software-end-of-life-checker").call(run_input={ "items": [ "nodejs 18", "python 3.8", "postgresql 12", "ubuntu 20.04", "angular 15" ], "nearEolDays": 180 }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ``` ```bash curl -X POST "https://api.apify.com/v2/acts/cliqtomedia~software-end-of-life-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"items": ["nodejs 18", "python 3.8", "postgresql 12", "ubuntu 20.04", "angular 15"], "nearEolDays": 180}' ``` ```python # pip install langchain-apify # set APIFY_TOKEN in your environment from langchain_apify import ApifyActorsTool tool = ApifyActorsTool("cliqtomedia/software-end-of-life-checker") result = tool.invoke({"run_input": {"items": ["nodejs 18", "python 3.8", "postgresql 12", "ubuntu 20.04", "angular 15"], "nearEolDays": 180}}) print(result) ``` run-sync waits up to 300 seconds; for longer runs start a run and use a webhook. LlamaIndex and MCP: https://cliqtomedia.com/actors/ai-agents/ ## Similar tools - [Link Route Audit — Bulk HTTP Status & Redirects](https://cliqtomedia.com/actors/bulk-url-status-redirect-checker/) - [GitHub Releases Monitor & Scraper](https://cliqtomedia.com/actors/github-releases-monitor-scraper/) - [Dependency Vulnerability Scanner (OSV)](https://cliqtomedia.com/actors/osv-dependency-vulnerability-scanner/) - [GitHub Repositories & Users Search (No Login)](https://cliqtomedia.com/actors/github-search/) - [OpenAPI Catalog & Breaking Change Detector](https://cliqtomedia.com/actors/openapi-spec-catalog-diff/) - [SSL Certificate Checker: Expiry, Chain & CT, No Login](https://cliqtomedia.com/actors/ssl-certificate-inspector/)