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 required values are validated before requests begin. query applies only to search and category only to category mode; other modes ignore them. Search trims the query and delegates matching/ranking to Flathub, not an exact-phrase or whole-field matcher.

Search, category, and ranked collections continue across pages until the global maxItems unique-app limit or source exhaustion. A billing budget can stop output earlier. Empty or repeated/no-progress pages stop pagination; a finite safety bound allows up to eight extra pages for duplicates/drift. Fewer results can therefore mean exhaustion or a partial snapshot, not a complete catalog census.

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:

{
  "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, enrichmentStatus

Fields are nullable because not every publisher supplies every metadata value. enrichmentStatus.detail and .summary report ok, failed, or notRequested. ok means the surface was fetched, not that every publisher field exists. Optional failures retain useful listing fields; total lookup failure for an exact rich ID fails clearly.

Release timestamps accept source seconds as numbers or numeric strings. latestReleaseAt uses the first exposed release timestamp, falling back to the package-summary timestamp when unavailable; that fallback is a package build time, not a proven publisher release date. Release order is preserved from Flathub. Runtime uses detail bundle metadata, then package-summary metadata, then listing data.

Example output

{
  "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 live 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. all and list-only appIds rows can contain only identity and provenance. List-only appIds validates requested IDs against Flathub's apps index in one bounded lookup; an unknown requested ID fails the run before any item output or item charge (the start fee still applies).

Bulk list-only example, crossing the first 250-result page:

{"mode":"popular","maxItems":500,"includeDetails":false,"locale":"en"}

Exact-ID release-monitor snapshot (schedule it and compare versions/dates yourself):

{"mode":"appIds","appIds":["org.mozilla.firefox","org.gimp.GIMP"],"maxItems":2,"includeDetails":true,"locale":"en"}

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

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

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

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:

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:

{
  "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.”

Follow one run to bounded results

Use this consumer recipe after authorizing an Actor invocation; the numbers below are example client choices, not Actor limits or Apify defaults:

1. Discover the needed tools. Keep the stable Actor-specific URL above. Actor selection also adds get-actor-run, get-dataset-items, get-key-value-store-record, and abort-actor-run; it does not expose exactly one tool. Inspect scoped tools/list for actual names and argument schemas, then use only the needed Actor/run/data subset. Discovery itself does not authorize execution or aborting a run.
2. Start once and retain the run. For example, request the Firefox/GIMP input above through the discovered Actor invocation tool. Retain the returned run ID, status, and storage IDs: these are metadata, not result rows. If using call-actor, waitSecs is 0–45 seconds (default 30), so a response need not mean completion. For a nonterminal run, follow that same run ID with get-actor-run, waiting 2, 4, then 8 seconds between checks, capped at 10 seconds, within a total 120-second consumer deadline. Set each client request timeout above the selected server wait plus transport margin, but within the remaining deadline. After a client timeout, recover/check the known run instead of starting another; if its ID is unknown, report uncertainty rather than blindly rerunning. At the deadline, stop polling and report pending with the run ID. Report terminal failures honestly; any available rows are partial, not a successful full result.
3. Read actual output within a context budget. On success, use get-dataset-items with the returned defaultDatasetId, explicit limit: 20, offset: 0, and only needed fields (for example appId,name,runtime,releases,enrichmentStatus), using the discovered argument schema. Prefer untransformed JSON. Page by source offsets and pagination metadata, not transformed row counts: filtering or unwinding can change returned counts. Across all pages admitted to model context, stop at 100 source rows or 64 KiB of serialized UTF-8 result content, whichever comes first, or at source exhaustion. Process pages host-side before model injection and track the cumulative rows/bytes. Omit or summarize an oversized row/page with explicit disclosure; never silently claim completeness. Report rows actually returned, the next source offset (including any omitted records), and partial/truncated status when incomplete. Keep full exports/downloads in storage or downstream processing outside model context. These consumer limits do not change this Actor's collection defaults, 1,000-item ceiling, features, or output fields.
4. Enforce limits in the client. A hard byte ceiling requires client-side interception before content reaches the model. If your client cannot intercept oversized responses, do not claim a hard byte guarantee or request unbounded results. Discovery transport bytes are not necessarily model-visible context; tool discovery/caching, progressive loading, and prompt caching depend on the client and negotiated capabilities. No universal token-saving claim is made.

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, logs the missing enrichment, and marks the affected enrichmentStatus surface as failed.

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.

Diagnostics and privacy

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. No credentials are required in Actor input. The Actor uses no AI models and sends no data for model training. Public catalog records may include publisher/developer names and public contact links supplied by Flathub. Only public catalog metadata is exported; application binaries and media are not downloaded.

Datasets, input, and logs remain in your Apify run storage under your account's retention settings until expiry or deletion; this Actor keeps no cross-run cache or history. Delete run storage in Apify Console/API to remove your snapshot. Diagnostic reports expire after 30 days. Apify hosts execution and storage; our private GlitchTip service receives only sanitized failure diagnostics.

Legality and responsible use

This independent automation-lab Actor collects public application-catalog metadata. It is not affiliated with or endorsed by Flathub, the Linux projects, or their publishers. Source/product names identify the public data being collected.

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 for Android app-market metadata.
• Apple App Store Developer Portfolio Scraper for publisher portfolio analysis.
• 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.