# Video Game Magazine Article & Scan Finder (`dalborgo/amf`) Actor

Search video game magazine articles on Abandonware France and get issue details, page numbers, sources, scan albums and download links in JSON.

- **URL**: https://apify.com/dalborgo/amf.md
- **Developed by:** [Marco Dal Borgo](https://apify.com/dalborgo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 article returneds

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

## Video Game Magazine Article & Scan Finder

[English](#english) · [Français](#francais)

### English

Find magazine coverage of a video game using **Abandonware France**, then get
the magazine, issue, publication date, article type, rating, page number and
archive source. For issues hosted by **Abandonware Magazines**, the Actor also
finds scan albums, individual page scans and direct download links when available.
Results are returned as JSON.

#### Input

```json
{
  "query": "sanitarium",
  "refresh": false,
  "useCache": true
}
```

| Field | Required | Default | Description |
| --- | --- | --- | --- |
| `query` | Yes | None | Game name or search keywords, up to 200 characters. All article result pages are collected. |
| `refresh` | No | `false` | Fetch fresh metadata from the websites, bypassing cached entries. |
| `useCache` | No | `true` | Reuse valid metadata across runs to reduce website requests. |

The example game is not a default search. Start with the game you want to research.

#### Article records

The dataset contains one JSON record per article, saved after its source and
links have been checked. Different articles in the same issue remain separate records.

| Fields | Contents |
| --- | --- |
| `id`, `title` | Stable article identifier and original title, including the platform when listed. |
| `magazine`, `issue`, `date` | Magazine name, original issue number and publication date in month/year format. |
| `articleType`, `rating`, `page` | Original article type, optional rating and page reference. |
| `source`, `sourceUrl`, `issueUrl` | Archive source, source link and original Abandonware France issue page. |
| `albumUrl`, `pageUrl` | Complete scan album and the individual page scan, when identified. |
| `downloadUrl`, `downloadFormat`, `downloadPageUrl` | Direct download, actual file format and download page. |
| `googleSearchUrl` | Google search link containing magazine, issue number and source for alternative archives. |
| `sourceIssue`, `sourceDate` | Matching issue number and date from the Abandonware Magazines catalog. |
| `linkStatus`, `linkNote` | Link lookup outcome and explanation. **All generated `linkNote` messages are in English.** |

Missing values are `null`. Issue numbers and page references remain strings to
preserve leading zeros, special issues and supplements. Original titles, article
types and archive names keep the language used by the source website.

For example, an article without a page reference can include:

```json
{
  "page": null,
  "linkNote": "Page not provided by the source website; please check the scan album."
}
```

Abandonware Magazines issues are matched against the catalog using issue number
and date. Ambiguous matches do not produce guessed links. Other archives such as
OldGameMags, Retromags and Internet Archive are reported with their source link
and a Google search URL. The Actor does not query Google or search those archives.

The Actor returns file URLs without downloading magazines or converting files.
`downloadFormat` reflects the actual available format, such as ZIP or PDF. A ZIP
containing page images is not converted into a PDF. If a specific page cannot be
identified, the album may still be available.

#### Pricing

Pay per event, with run platform usage included:

| Event | Price (USD) |
| --- | ---: |
| Search started | $0.01 per run |
| Article returned | $0.002 per dataset record ($2 per 1,000 articles) |

A search returning 47 articles costs $0.104 at these base rates. The startup
charge also applies when no articles match. An article is billed once when saved
to the dataset, even if its source is an alternative archive or it has no direct
download link. OUTPUT does not trigger another article charge. Apify tier discounts
may apply. Later storage access is subject to Apify's standard storage pricing.

Set **Maximum cost per run** to control your budget (minimum $0.012, covering
startup and one article). If another article would
exceed it, the Actor stops and returns only saved records. OUTPUT then reports
`budgetReached: true` and a partial search. Dataset and OUTPUT contain the same
saved articles in pay-per-event mode, including during partial runs.

#### Search summary and partial results

The **OUTPUT** key-value store record contains `results` in the original search
order, along with `query`, `totalResults`, `returnedResults`, `status`, `complete`,
`linksComplete`, `budgetReached`, `warnings`, `stats`, `startedAt` and `finishedAt`.

- `complete` means that all article result pages were collected.
- `linksComplete` means that no link checks were interrupted or failed with a technical error.
- `stats.requests` counts website requests, including retries; `stats.cached` counts cache reads served successfully.
- `status` is `running`, `completed`, `partial`, `failed` or `aborted`.

Final article statuses are `found`, `other-source`, `no-source`, `not-found`,
`partial` and `error`. During processing, `pending` may appear in OUTPUT;
after a handled interruption, unfinished records are marked `stopped`.
A complete search can still contain missing sources, unmatched issues or missing page scans.

The dataset is saved progressively. OUTPUT is updated periodically and at the
end. After a forced stop, the last summary may still say `running`; check the
Apify run status too. A restarted run repeats the search using cached metadata
and avoids appending article IDs already present in its dataset. Use a new run
to refresh previously saved results.

#### Cache and API

Cloud metadata is stored in `amf-metadata-v1`. Search entries expire after one
hour; sources and downloads after one day; catalogs, issue lists and albums
after seven days. Expired entries are refreshed when used. Failed requests are
not cached. With `useCache: false`, metadata is only reused within the current run.

Website requests are sequential, with a 250 ms pause and up to three attempts
for temporary failures. Each request has a 30-second timeout. Broad searches may
take several minutes. Default run settings are 512 MB of memory and a 15-minute timeout.

Send your input with account authentication to:

```text
POST https://api.apify.com/v2/acts/dalborgo~amf/run-sync-get-dataset-items?format=json
```

This returns the JSON array of article records. The synchronous endpoint has a
five-minute limit. For longer searches, start a run asynchronously and retrieve
its dataset and OUTPUT after completion. See the [Apify API reference](https://docs.apify.com/api/v2/actor-run-sync-get-dataset-items-post).

### Français

#### Recherche d’articles et de scans de magazines de jeux vidéo

Recherchez les articles consacrés à un jeu sur **Abandonware France** et obtenez
le magazine, le numéro, la date de publication, le type d’article, la note,
la page et la source d’archive. Pour les numéros disponibles sur **Abandonware
Magazines**, l’Actor recherche également l’album de scans, le scan de la page
et le lien de téléchargement direct lorsqu’ils sont disponibles. Les résultats
sont fournis en JSON.

#### Entrée

```json
{
  "query": "sanitarium",
  "refresh": false,
  "useCache": true
}
```

| Champ | Obligatoire | Valeur par défaut | Description |
| --- | --- | --- | --- |
| `query` | Oui | Aucune | Nom du jeu ou mots-clés, jusqu’à 200 caractères. Toutes les pages de résultats d’articles sont récupérées. |
| `refresh` | Non | `false` | Récupérer les métadonnées depuis les sites en ignorant les entrées du cache. |
| `useCache` | Non | `true` | Réutiliser les métadonnées valides entre les exécutions pour limiter les requêtes. |

Le jeu de l’exemple n’est pas une recherche par défaut. Indiquez le jeu souhaité.

#### Articles et liens

Le dataset contient un objet JSON par article, enregistré après vérification
de sa source et de ses liens. Plusieurs articles d’un même numéro restent distincts.

| Champs | Contenu |
| --- | --- |
| `id`, `title` | Identifiant stable et titre original, avec la plateforme lorsqu’elle est indiquée. |
| `magazine`, `issue`, `date` | Magazine, numéro original et date au format mois/année. |
| `articleType`, `rating`, `page` | Type d’article original, note éventuelle et référence de page. |
| `source`, `sourceUrl`, `issueUrl` | Source d’archive, lien vers cette source et fiche originale sur Abandonware France. |
| `albumUrl`, `pageUrl` | Album complet et scan de la page lorsqu’elle est identifiée. |
| `downloadUrl`, `downloadFormat`, `downloadPageUrl` | Téléchargement direct, format réel du fichier et page de téléchargement. |
| `googleSearchUrl` | Recherche Google avec le magazine, le numéro et la source pour les autres archives. |
| `sourceIssue`, `sourceDate` | Numéro et date trouvés dans le catalogue Abandonware Magazines. |
| `linkStatus`, `linkNote` | Résultat de la vérification et explication. **Les messages générés dans `linkNote` sont toujours en anglais.** |

Les valeurs manquantes sont `null`. Les numéros et les pages restent des chaînes
de caractères pour conserver les zéros initiaux, les hors-séries et les suppléments.
Les titres, types d’articles et noms d’archives conservent la langue du site d’origine.
Lorsqu’une page n’est pas indiquée, `linkNote` peut contenir :

```json
{
  "page": null,
  "linkNote": "Page not provided by the source website; please check the scan album."
}
```

La correspondance avec Abandonware Magazines utilise le numéro et la date du
catalogue. Les correspondances ambiguës ne donnent pas lieu à des liens supposés.
Pour OldGameMags, Retromags, Internet Archive et les autres sources, l’Actor
renvoie le lien d’origine et une URL de recherche Google. Il ne consulte pas
Google et ne recherche pas automatiquement dans ces autres archives.

L’Actor fournit des URL sans télécharger les magazines ni convertir les fichiers.
Le format annoncé correspond au fichier disponible, par exemple ZIP ou PDF.
Une archive ZIP contenant des images n’est pas convertie en PDF. Si le scan de
la page n’est pas identifié, l’album peut rester accessible.

#### Tarification

Paiement par événement, avec les ressources du run incluses :

| Événement | Prix (USD) |
| --- | ---: |
| Recherche démarrée | 0,01 $ par run |
| Article retourné | 0,002 $ par objet du dataset (2 $ pour 1 000 articles) |

Une recherche retournant 47 articles coûte 0,104 $ à ces tarifs de base. Le coût
de démarrage s'applique aussi si aucun article ne correspond. Un article est
facturé une seule fois lorsqu'il est enregistré dans le dataset, même s'il provient
d'une autre archive ou ne dispose pas de téléchargement direct. OUTPUT ne génère
aucune seconde facturation de l'article. Les remises Apify peuvent s'appliquer.
Les accès au stockage après le run suivent la tarification standard d'Apify.

Définissez **Maximum cost per run** pour contrôler votre budget (minimum 0,012 $,
soit le démarrage et un article). Si l'article
suivant dépasse ce plafond, l'Actor s'arrête et retourne seulement les objets
enregistrés. OUTPUT indique alors `budgetReached: true` et une recherche partielle.
En mode pay-per-event, le dataset et OUTPUT contiennent les mêmes articles
enregistrés, y compris pour les runs partiels.

#### Récapitulatif et résultats partiels

Le record **OUTPUT** du key-value store contient `results` dans l’ordre de la
recherche d’origine ainsi que `query`, `totalResults`, `returnedResults`, `status`,
`complete`, `linksComplete`, `budgetReached`, `warnings`, `stats`, `startedAt` et `finishedAt`.

- `complete` indique que toutes les pages de résultats d’articles ont été récupérées.
- `linksComplete` indique qu’aucune vérification n’a été interrompue ou n’a échoué à cause d’une erreur technique.
- `stats.requests` compte les requêtes aux sites, y compris les nouvelles tentatives ; `stats.cached` compte les lectures servies depuis le cache.
- `status` vaut `running`, `completed`, `partial`, `failed` ou `aborted`.

Les états finaux des articles sont `found`, `other-source`, `no-source`,
`not-found`, `partial` et `error`. Pendant le traitement, OUTPUT peut contenir
`pending` ; après une interruption gérée, les vérifications inachevées deviennent
`stopped`. Une recherche complète peut contenir des articles sans source,
des numéros non identifiés ou des scans de pages manquants.

Le dataset est enregistré progressivement. OUTPUT est mis à jour périodiquement
et à la fin. Après un arrêt forcé, le dernier récapitulatif peut encore indiquer
`running` : consultez aussi l’état du run Apify. Un run redémarré reprend la
recherche avec le cache et évite d’ajouter les identifiants déjà présents dans
son dataset. Pour actualiser des résultats enregistrés, démarrez un nouveau run.

#### Cache et API

Le cache cloud utilise `amf-metadata-v1`. Les recherches expirent après une heure,
les sources et téléchargements après un jour, les catalogues, listes de numéros
et albums après sept jours. Les entrées expirées sont actualisées à leur prochaine
utilisation. Les erreurs ne sont pas mises en cache. Avec `useCache: false`,
les métadonnées sont seulement réutilisées pendant le run courant.

Les requêtes sont séquentielles, espacées de 250 ms, avec jusqu’à trois tentatives
en cas d’erreur temporaire. Chaque requête expire après 30 secondes. Une recherche
large peut prendre plusieurs minutes. Le run utilise par défaut 512 Mo de mémoire
avec un délai maximal de 15 minutes.

Envoyez votre entrée avec l’authentification de votre compte à :

```text
POST https://api.apify.com/v2/acts/dalborgo~amf/run-sync-get-dataset-items?format=json
```

La réponse est le tableau JSON des articles. Cet endpoint synchrone est limité
à cinq minutes. Pour les recherches plus longues, lancez le run de manière
asynchrone et récupérez son dataset et OUTPUT une fois terminé.
Consultez la [documentation de l’API Apify](https://docs.apify.com/api/v2/actor-run-sync-get-dataset-items-post).

# Actor input Schema

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

Game name or keywords to search on Abandonware France. All article result pages are collected.

## `refresh` (type: `boolean`):

Bypass cached entries and fetch the required pages again.

## `useCache` (type: `boolean`):

Reuse valid metadata across runs to reduce requests. Images and magazines are not stored.

## Actor input object example

```json
{
  "query": "Sanitarium",
  "refresh": false,
  "useCache": true
}
```

# Actor output Schema

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

No description

## `result` (type: `string`):

No description

# 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": "Sanitarium"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dalborgo/amf").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": "Sanitarium" }

# Run the Actor and wait for it to finish
run = client.actor("dalborgo/amf").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": "Sanitarium"
}' |
apify call dalborgo/amf --silent --output-dataset

```

## MCP server setup

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

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/e1KYXbVVwROQ3nhfG/builds/oXkck6aPherx6DcZP/openapi.json