# Curated Finds (`myworkingmemory/software-library-search`) Actor

Curated GitHub tools and Hugging Face models for those “I didn’t know that was possible” moments. Browse the finds with descriptions, source links and setup information. Updated daily, with discoveries and updates throughout the day.

- **URL**: https://apify.com/myworkingmemory/software-library-search.md
- **Developed by:** [Myworkingmemory LLC](https://apify.com/myworkingmemory) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.95 / 1,000 curated feed pages

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

## Curated Finds

Browse a curated public feed of software, models and tools, with source links, access links, requirements, evidence limits and original source-review dates. No search is required. The full public catalogue is available through pages of up to 25 records; optional search and filters help narrow it.

You are buying one catalogue page per run. The linked software and models are provided by their original maintainers. This service does not install or run them.

### Browse the feed

Use a paid Apify account. Set a finite maximum run cost that covers the displayed startup and `catalog-search` charges, then start the Actor with no search or filter input:

```json
{}
```

When the run succeeds, open **Finds** to read the records or export them through Apify as CSV or JSON. The same records are also preserved in `OUTPUT` in the run's key-value store, with the catalogue version, source-review date, evidence basis, total count and pagination. Each record retains all 13 public fields: ID, name, purpose, category, type, platforms, source URL, access URL, stated license label, license URL, requirements, evidence limits and source-review date. Missing source information remains empty.

For the next page, start another run with `{"offset":25}`, then `{"offset":50}` and so on until the records are exhausted. Each page is a separate run and charge. Check that the catalogue version matches across pages when collecting the full feed.

### Optional search and filters

Leave `query`, `category` and `platform` blank to browse every public record. To narrow the feed, for example, use `{"query":"speech","limit":5}`.

`query` accepts up to 200 characters; all meaningful query terms must match. `category` and `platform` are optional exact filters, matched without case sensitivity, each accepting up to 100 characters. `limit` is 1–25 and defaults to 25. `offset` is 0–10000 and defaults to 0; it skips records in the selected feed or filtered results.

Each run delivers one bounded page under the existing `catalog-search` event, whether or not search words are supplied. A valid empty page costs the same. Queries are searched as text; they are never opened as URLs or executed. Apify stores input as part of the run; keep it to software-search terms.

### Charges and results

Use the prices displayed by Apify before starting. The Actor requires native pay-per-event billing and sufficient remaining run budget. A startup charge can apply to invalid or aborted runs. One confirmed `catalog-search` charge precedes writing `OUTPUT` and the same records to the default dataset; the dataset adds no second `catalog-search` charge. If delivery fails after charging, inspect the existing `OUTPUT` and contact support with the run ID. An interrupted dataset write can leave partial rows. This Actor does not retry or recharge a previously charged run. Output is capped at 25 records and 512 KiB per run.

The catalogue follows reviewed additions. Its version identifies the snapshot delivered. Individual dates describe source review, which is separate from runtime and accessibility-fit testing; export or build time does not refresh them. Check each result's requirements and evidence limits.

[Product](https://www.myworkingmemory.ai/software-library) · [Support](https://www.myworkingmemory.ai/software-library-support.html) · [Privacy](https://www.myworkingmemory.ai/software-library-privacy.html) · [Terms](https://www.myworkingmemory.ai/software-library-terms.html)

Myworkingmemory LLC · dean@myworkingmemory.ai

# Actor input Schema

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

Return 1 to 25 records. Defaults to 25. Each page is one separately charged run, regardless of record count.

## `offset` (type: `integer`):

Start at 0; use 25, 50 and so on for later pages at the default page size. Maximum 10000. Each page requires another run.

## `query` (type: `string`):

Leave blank to browse. Optional words match name, purpose, category, type and platforms; all meaningful words must match. Input is searched as text, never opened as a URL or executed.

## `category` (type: `string`):

Leave blank for all categories, or enter a category for a case-insensitive exact match.

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

Leave blank for all platforms, or enter a platform for a case-insensitive exact match.

## Actor input object example

```json
{
  "limit": 25,
  "offset": 0,
  "query": "",
  "category": "",
  "platform": ""
}
```

# Actor output Schema

## `finds` (type: `string`):

The same complete public records in this run's default dataset, available through Apify's native viewer and exports.

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

JSON containing catalogue version, review date, evidence basis, total count, pagination and at most 25 public records, with original source-review dates and evidence limits.

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

// Run the Actor and wait for it to finish
const run = await client.actor("myworkingmemory/software-library-search").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 = { "query": "" }

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

```

## MCP server setup

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

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/ghlTCYxrSCV2k1UzV/builds/hYMm7EjgGo4702ZZE/openapi.json