# Software Acquisition Scout (`prominent_piazza/software-acquisition-scout`) Actor

Find software projects to research across WordPress.org, Chrome Web Store and Atlassian Marketplace. Rank candidates with heuristic signals and compare saved scans. Scores do not establish abandonment, availability, ownership rights or acquisition value.

- **URL**: https://apify.com/prominent\_piazza/software-acquisition-scout.md
- **Developed by:** [James Schroeder](https://apify.com/prominent_piazza) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 scored candidates

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?

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

## Software Acquisition Scout

Research software projects worth a closer look across three public
marketplaces: WordPress.org plugins, the Chrome Web Store, and the Atlassian
Marketplace. Each run screens one marketplace, scores candidates with
heuristic signals, flags deal risks, and reports what changed since your
last scan.

Scores do not establish abandonment, availability, ownership rights, or
acquisition value. They are research signals — verify before acting.

### How a run works

1. Pick a marketplace and set your filters (see Input below).
2. The actor screens that marketplace, enriches each candidate, and pushes one
   JSON object per candidate to the run's dataset, sorted by distribution
   value score.
3. A `RUN-SUMMARY` record is written to the run's key-value store with the
   platform, counts (pushed / blocked by charge limit / unattempted), whether
   a charge limit was reached, and the input used.

### Input

One run screens one marketplace. All fields are optional except `platform`.

| Field | Default | What it does |
|---|---|---|
| `platform` | `wordpress` | Marketplace to screen: `wordpress`, `chrome`, or `atlassian`. |
| `limit` | `25` | Maximum candidates returned, sorted by distribution value score (1–200). |
| `minimum_users` | `500` | Skip assets below this install count. The scoring sweet spot is 500–20,000 installs. |
| `minimum_rating` | `3.0` | Skip assets rated below this (0–5). Assets with no public rating are skipped. |
| `minimum_age_days` | `365` | Skip assets younger than this (proven-longevity signal). |
| `days_since_update` | `365` | Only consider assets not updated for at least this long (abandonment signal). |
| `maximum_competitor_count` | `50` | Skip assets whose niche has more competing listings than this. |

Example input:

```json
{
  "platform": "wordpress",
  "minimum_users": 500,
  "minimum_rating": 3.0,
  "minimum_age_days": 365,
  "days_since_update": 365,
  "maximum_competitor_count": 50,
  "limit": 25
}
```

### Output

Each dataset item describes one candidate with these fields:

- `asset` — asset name. `platform` — marketplace screened.
- `users_installs`, `rating`, `reviews` — public traction figures.
- `last_release`, `release_frequency_trend`, `support_backlog` — maintenance signals.
- `developer_activity` — version and "tested up to" information where public.
- `known_monetization`, `competitor_pricing` — how the asset and its niche make money.
- `abandonment_probability` — **0–1 heuristic score, not a calibrated
  probability.** Higher means more abandonment signals; it is not proof that
  an asset is abandoned.
- `distribution_value_score` — 0–1 heuristic ranking score combining existing
  users, organic discovery, monetization gap, maintenance simplicity,
  abandonment evidence, competitor pricing, and review quality.
- `estimated_technical_complexity` — 1–5 maintenance estimate (lower is simpler).
- `acquisition_takeover_route` — how a takeover could realistically proceed on
  that marketplace (e.g. the wordpress.org adoption flow or direct owner transfer).
- `red_flags` — risk flags such as `single_maintainer`. Flags, not disqualifiers.
- `changed_since_last_scan` — installs / rating / reviews deltas, whether a new
  release appeared, and days between scans, computed from your cross-run history.
- `source_evidence` — listing URL, source URLs, competitor count, and
  `coverage_warnings` listing exactly what was unavailable on that platform.

### Platform coverage

- **WordPress.org** — public plugin metadata; individual fields can be unavailable.
- **Chrome Web Store** — detail pages are JavaScript-rendered. The actor reads
  static HTML only: install counts are unavailable, and rating, reviews, and
  last-update are best-effort extractions that often miss. Expect few or zero
  results. Each item's
  `source_evidence.coverage_warnings` states what was missing.
- **Atlassian Marketplace** — public REST data. App age and support backlog are
  not public.

### Cross-run history

Repeat scans of the same marketplace build on your history. Snapshots are kept
in a named, account-scoped key-value store (`scout-history-v2-…`, the suffix
is derived from your account and scan configuration), one immutable record per
snapshot. Reads return up to 25 recent snapshots per asset; stored history may
grow until removed. Only the same account with the same scan configuration
shares a history store. This is what powers `changed_since_last_scan`.
Records are retained; cleanup is a separate maintenance step and never
something a scan does to your history.

### Data retention

The actor does not delete these records; Apify account/platform retention
applies to run datasets and default key-value store summaries. Named history
is retained until removed.

### Support

Questions or issues: james@jbschroeder.co

### Pricing and spending limits

At up to 1 GB allocated memory, each run incurs a USD 0.50 start charge plus USD 0.10 for each scored candidate saved to the default dataset. Each additional GB increases the number of start charges. At the default 1 GB memory, zero candidates cost USD 0.50, 20 cost USD 2.50, and 25 cost USD 3.00, subject to the configured spending limit. A failed run may still incur its start charge and charges for results delivered before failure.

Set a maximum charge per run in Apify before starting. The saved pricing uses standard pay per event with platform usage included, not the optional additional platform-usage charge. Review the Pricing tab for current rates. Start with WordPress.org; Chrome coverage can produce few or no results as explained above.

# Actor input Schema

## `days_since_update` (type: `integer`):

Only consider assets not updated for at least this long (abandonment signal).

## `limit` (type: `integer`):

Maximum number of scored candidates to return (sorted by distribution value score).

## `maximum_competitor_count` (type: `integer`):

Skip assets whose niche has more competing listings than this.

## `minimum_age_days` (type: `integer`):

Ignore assets younger than this (proven longevity signal).

## `minimum_rating` (type: `number`):

Ignore assets rated below this. Assets with no public rating are skipped.

## `minimum_users` (type: `integer`):

Ignore assets below this install count. The scoring sweet spot is 500-20,000 installs.

## `platform` (type: `string`):

Marketplace to screen. WordPress returns full data. Chrome Web Store detail pages are JS-rendered: static HTML only, install counts unavailable, rating/reviews best-effort; expect few or zero results until the browser pass ships. Atlassian: app age and support backlog are not public.

## Actor input object example

```json
{
  "days_since_update": 365,
  "limit": 25,
  "maximum_competitor_count": 50,
  "minimum_age_days": 365,
  "minimum_rating": 3,
  "minimum_users": 500,
  "platform": "wordpress"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing the scored acquisition candidates

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("prominent_piazza/software-acquisition-scout").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("prominent_piazza/software-acquisition-scout").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 '{}' |
apify call prominent_piazza/software-acquisition-scout --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,prominent_piazza/software-acquisition-scout"
        }
    }
}
```

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/JMORkz3S6PRhz8beR/builds/yZZyjdZqnb5k2ytjG/openapi.json