# Flathub Linux Applications Scraper (`automation-lab/flathub-linux-application-catalog`) Actor

Search or enumerate Flathub apps and export normalized metadata, releases, developers, licenses, verification, media, package sizes, and popularity signals.

- **URL**: https://apify.com/automation-lab/flathub-linux-application-catalog.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (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.36 / 1,000 item extracteds

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?

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

## Flathub Linux Applications Scraper

Export structured **Flathub Linux applications** data for catalog analysis, release tracking, software discovery, and recurring monitoring.

The Actor searches or enumerates public applications from Flathub and returns normalized records with Flatpak IDs, names, descriptions, categories, developers, licenses, verification, releases, screenshots, package sizes, architectures, and available popularity signals.

It uses Flathub's public structured interfaces. No Flathub account, cookies, or API key are required.

### What can you do with this Flathub scraper?

- Search applications by a buyer-defined phrase.
- Browse popular, trending, most-favorited, recently added, or recently updated apps.
- Export one Flathub category.
- Enrich exact Flatpak application IDs.
- Enumerate the catalog alphabetically.
- Capture release versions and dates for change comparison.
- Compare developers, licenses, verification, architectures, and runtimes.
- Load clean JSON, CSV, or Excel data into an analysis pipeline.
- Schedule repeat runs and compare snapshots in your own database or workflow.

The Actor produces a snapshot. It does not send alerts or retain history between runs.

### Who is this Actor for?

#### Linux ecosystem analysts

Build a current application inventory and measure changes in the Flathub ecosystem.

#### Application publishers

Check public listing identity, release, verification, media, package-size, and runtime metadata.

#### Open-source researchers

Compare licenses, developers, categories, architectures, and release cadence across applications.

#### Data and integration teams

Feed normalized Flathub records into spreadsheets, warehouses, dashboards, or scheduled automations.

### Why use this Actor?

Flathub exposes rich application data across search, collection, AppStream, and package-summary surfaces.

This Actor joins those surfaces into one consistent record per application.

It also provides:

- nine selection modes;
- strict limits from 1 to 1,000 records;
- stable deduplication by Flatpak application ID;
- optional low-request list-only exports;
- bounded retries for temporary upstream failures;
- typed fields and an Apify dataset table view;
- pay-per-result billing with no charge for rejected or duplicate records.

### Supported discovery modes

| Mode | Purpose | Required input |
| --- | --- | --- |
| `search` | Find apps by text | `query` |
| `category` | Export a Flathub main category | `category` |
| `popular` | Apps with the most installs in the previous month | none |
| `recentlyAdded` | Newly added applications | none |
| `recentlyUpdated` | Recently released or updated applications | none |
| `trending` | Apps gaining recent install momentum | none |
| `favorites` | Apps with the most Flathub favorites | none |
| `appIds` | Enrich exact Flatpak IDs | `appIds` |
| `all` | Enumerate application IDs alphabetically | none |

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `popular` | One of the supported discovery modes. |
| `query` | string | — | Search phrase required by `search`. |
| `category` | string | — | Main category required by `category`, such as `game`, `network`, `development`, or `graphics`. |
| `appIds` | string\[] | — | Exact Flatpak IDs required by `appIds`. |
| `locale` | string | `en` | Metadata locale such as `en`, `de`, or `en-US`. |
| `maxItems` | integer | `25` | Maximum unique records, from 1 to 1,000. |
| `includeDetails` | boolean | `true` | Enrich with release, screenshot, URL, architecture, and size data. |

Mode-specific values are validated before requests begin.

### Getting started

1. Open the Actor input form.
2. Choose a discovery mode.
3. Enter its query, category, or app IDs when required.
4. Set `maxItems` to the snapshot size you need.
5. Keep `includeDetails` enabled for the richest records.
6. Click **Start**.
7. Open **Dataset** to preview or download the results.

A useful first input is:

```json
{
  "mode": "search",
  "query": "web browser",
  "maxItems": 10,
  "includeDetails": true,
  "locale": "en"
}
```

### Output fields

Every dataset item represents one Flathub application.

| Group | Fields |
| --- | --- |
| Identity | `appId`, `name`, `summary`, `description`, `type`, `sourceUrl` |
| Publisher | `developer`, `isVerified`, `verificationMethod`, `verificationWebsite` |
| Classification | `categories`, `subcategories`, `keywords`, `isMobileFriendly` |
| License | `license`, `isFreeLicense` |
| Platform | `architectures`, `runtime`, `branch`, `isEndOfLife` |
| Timeline | `addedAt`, `updatedAt`, `latestReleaseVersion`, `latestReleaseAt`, `releases` |
| Popularity | `installsLastMonth`, `favoritesCount`, `trendingScore` |
| Package | `downloadSizeBytes`, `installedSizeBytes` |
| Media and links | `iconUrl`, `screenshotUrls`, `homepageUrl` |
| Provenance | `discoveryMode`, `scrapedAt` |

Fields are nullable because not every publisher supplies every metadata value.

### Example output

```json
{
  "appId": "org.mozilla.firefox",
  "name": "Firefox",
  "summary": "Fast, Private & Safe Web Browser",
  "developer": "Mozilla",
  "license": "MPL-2.0",
  "isFreeLicense": true,
  "isVerified": true,
  "verificationMethod": "manual",
  "categories": ["Network", "WebBrowser"],
  "architectures": ["aarch64", "x86_64"],
  "latestReleaseVersion": "155.0.1",
  "downloadSizeBytes": 125615082,
  "sourceUrl": "https://flathub.org/apps/org.mozilla.firefox",
  "discoveryMode": "appIds"
}
```

Values reflect the public source at run time and can change between snapshots.

### How much does it cost to export Flathub applications?

The Actor uses pay per event pricing:

- **$0.005** once when a run starts;
- a tiered price for each unique application saved.

The planned BRONZE item price is **$0.002272 per application**. Example BRONZE totals are approximately:

| Applications | Estimated total |
| ---: | ---: |
| 1 | $0.007272 |
| 10 | $0.02772 |
| 100 | $0.23220 |
| 1,000 | $2.27700 |

Apify subscription tiers use different item rates. The Console shows the applicable live rate before a run.

Upstream retries do not create extra result charges. Empty, rejected, and duplicate rows are not charged as items.

### Search and category tips

Use a buyer-relevant phrase instead of a long question.

Good search examples include:

- `web browser`
- `photo editor`
- `password manager`
- `music player`

Flathub main category names include `audiovideo`, `development`, `education`, `game`, `graphics`, `network`, `office`, `science`, `system`, and `utility`.

Category matching follows Flathub's current taxonomy.

### Catalog monitoring workflow

For a recurring change workflow:

1. Use `recentlyUpdated` or `all` with a stable limit.
2. Keep the locale and detail setting unchanged.
3. Schedule the Actor in Apify Console.
4. Export each dataset to your warehouse or automation.
5. Compare rows by `appId`.
6. Detect changes in `updatedAt`, `latestReleaseVersion`, verification, runtime, license, or sizes.

The Actor supplies snapshots; your destination owns comparison rules and alert delivery.

### Faster list-only exports

Set `includeDetails` to `false` when collection/search fields are sufficient.

This avoids per-app AppStream and package-summary requests.

List-only rows can still include:

- identity and descriptions;
- developer and license;
- categories and verification;
- runtime and architectures;
- installs, favorites, and trending values where the selected collection exposes them.

Release history, screenshots, homepage, and package sizes generally require details.

### Integrations

You can connect the result dataset to:

- Google Sheets for catalog review;
- Make or Zapier for scheduled downstream steps;
- webhooks for run-completion processing;
- BigQuery, Snowflake, PostgreSQL, or object storage;
- Python, JavaScript, R, or BI notebooks;
- Apify schedules for recurring snapshots.

Use `appId` as the stable merge key.

### Run with the Apify API

Replace `YOUR_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~flathub-linux-application-catalog/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"recentlyUpdated","maxItems":25,"includeDetails":true}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/flathub-linux-application-catalog').call({
    mode: 'search',
    query: 'photo editor',
    maxItems: 25,
    includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/flathub-linux-application-catalog").call(
    run_input={
        "mode": "appIds",
        "appIds": ["org.mozilla.firefox", "org.gimp.GIMP"],
        "maxItems": 2,
        "includeDetails": True,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Model Context Protocol (MCP)

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/flathub-linux-application-catalog"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/flathub-linux-application-catalog"
    }
  }
}
```

Example prompts:

- “Search Flathub for password managers and compare their licenses and verification.”
- “Export Firefox and GIMP release metadata from their Flatpak IDs.”
- “Get 50 recently updated Flathub apps for my weekly catalog snapshot.”

### Reliability and retry behavior

Requests have a 30-second timeout.

Temporary network failures, HTTP 429 responses, and server errors receive at most three attempts with bounded exponential backoff and jitter.

Invalid input and stable client errors are not blindly retried.

The Actor uses up to five concurrent detail operations and stops at `maxItems`.

If optional detail or package-summary data is unavailable for a discovered list row, the Actor preserves the useful listing fields and logs the missing enrichment.

### Limits and known gaps

- Results are current snapshots, not historical series.
- Popularity signals exist only where Flathub exposes them.
- Exact-ID mode may not include collection-specific install or trending values.
- Descriptions can contain publisher-provided markup or formatting.
- Release notes and media vary by publisher.
- `maxItems` is capped at 1,000 per run.
- The Actor does not download applications, binaries, screenshots, or icons.
- The Actor does not modify Flathub listings or publisher accounts.

### Troubleshooting

#### Why did search return fewer rows than `maxItems`?

Flathub may have fewer matching applications. The Actor never pads output with unrelated records.

#### Why are release or size fields null?

Keep `includeDetails` enabled. If it is enabled, the app may not expose that field or an optional detail endpoint may have been temporarily unavailable.

#### Why did my input fail before scraping?

Check that `query`, `category`, or `appIds` is present for the selected mode and that `maxItems` is between 1 and 1,000.

#### Why are installs null for an explicit app ID?

Install counts are collection/search signals and are not guaranteed on the detail endpoint used by exact-ID mode.

### Legality and responsible use

This Actor collects public application-catalog metadata.

You are responsible for your use of the data and for complying with applicable laws, Flathub terms, licenses, database rights, and downstream platform policies.

Do not use the Actor to overload the source, misrepresent publishers, or build deceptive rankings.

Publisher descriptions, screenshots, and release notes may have their own licenses. Review those terms before republication.

### FAQ

#### Does it require a Flathub account?

No. The supported workflow uses public, unauthenticated data.

#### Does it support multiple languages?

Yes. Supply a supported locale such as `en` or `de`; available translations depend on each application.

#### Can it export all Flathub IDs?

Yes. Use `all`. The Actor then enriches records up to `maxItems`.

#### Can I monitor new releases?

Use scheduled `recentlyUpdated` snapshots and compare `appId`, `latestReleaseVersion`, and `latestReleaseAt` in your destination.

#### Are downloads included?

No binaries are downloaded. `downloadSizeBytes` is public package metadata, while `installsLastMonth` is an aggregate signal exposed on supported collection/search results.

### Related automation-lab Actors

For a broader multi-source software workflow, combine this Actor with:

- [Google Play App Catalog & Details Scraper](https://apify.com/automation-lab/google-play-app-catalog-details) for Android app-market metadata.
- [Apple App Store Developer Portfolio Scraper](https://apify.com/automation-lab/apple-app-store-developer-portfolio-scraper) for publisher portfolio analysis.
- [Artifact Hub Packages Scraper](https://apify.com/automation-lab/artifact-hub-packages-scraper) for cloud-native package metadata.

Each related Actor has its own source contract and output schema.

### Support

If a public Flathub input starts failing, include the input mode, non-sensitive input, run URL, and expected record in an Apify issue.

Do not include API tokens or private downstream credentials.

# Actor input Schema

## `mode` (type: `string`):

Choose how applications are selected. Search uses query; category uses category; appIds uses explicit Flatpak IDs.

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

Keyword or phrase to search when mode is search, for example browser or photo editor.

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

Main Flathub category used when mode is category, for example Game, Network, Development, or Graphics.

## `appIds` (type: `array`):

Exact public Flathub IDs used when mode is appIds, for example org.mozilla.firefox.

## `locale` (type: `string`):

Locale for localized Flathub metadata, such as en, de, or en-US.

## `maxItems` (type: `integer`):

Maximum number of unique application records saved to the dataset.

## `includeDetails` (type: `boolean`):

Fetch each app's release history, screenshots, URLs, verification metadata, architectures, and package sizes.

## Actor input object example

```json
{
  "mode": "popular",
  "locale": "en",
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

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

Default dataset containing one normalized record per unique Flathub application.

# 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 = {
    "mode": "popular",
    "locale": "en",
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flathub-linux-application-catalog").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 = {
    "mode": "popular",
    "locale": "en",
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flathub-linux-application-catalog").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 '{
  "mode": "popular",
  "locale": "en",
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/flathub-linux-application-catalog --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/flathub-linux-application-catalog"
        }
    }
}
```

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/DLKyCnzPNbLMthSr0/builds/g3HpFY8U4bKfjhB4k/openapi.json