Comment utiliser IronWebScraper avec Google Antigravity

Curtis Chau
Curtis Chau
Mis à jour : 26 octobre 2026

Une équipe d'analystes en recrutement collecte chaque matin toutes les annonces d'un site d'emplois régional. Un parcours de quelques centaines de pages peut s'arrêter à mi-chemin lorsqu'un serveur redémarre, qu'un ordinateur portable se met en veille ou que quelqu'un appuie sur Ctrl+C. Lorsque le robot d'exploration redémarre, il doit terminer les pages restantes sans télécharger celles déjà traitées deux fois et sans écrire un emploi deux fois. Un parcours peut également se terminer sans erreur et toujours enregistrer un salaire que la page n'affiche plus. Aucun de ces défauts n'apparaît dans un journal de console.

Google Antigravity peut vérifier le parcours par rapport à la page telle qu'un demandeur d'emploi la voit. Sa commande /browser lance un sous-agent de navigateur qui ouvre chaque page et capture une capture d'écran. IronWebScraper conserve un cache web et peut redémarrer un parcours sous un identifiant de parcours, les fonctionnalités couvertes dans son tutoriel sur les fonctionnalités avancées de webscraping. Ce guide construit un robot d'exploration de panneaux d'emploi avec les deux outils et le teste contre une copie locale d'un panneau dont les 60 annonces sont connues à l'avance.

Ce guide est destiné aux développeurs utilisant des agents AI pour écrire des robots d'exploration .NET. Chaque parcours cible un panneau de test servi sur localhost, et il ne traite pas des sites que vous n'exploitez pas.

Démarrage rapide
NuGetInstaller avec NuGet

PM > Install-Package IronWebScraper

Installez IronWebScraper en exécutant la commande ci-dessus dans la console du gestionnaire de packages NuGet, ou recherchez le package dans le gestionnaire de packages NuGet.

Avec le projet HarborJobs.Crawler ouvert dans Antigravity, décrivez le parcours.

/plan Build a crawler for Harbor Jobs, the local test board at http://localhost:5481.
This repo is a .NET 9 console app named HarborJobs.Crawler.
Install IronWebScraper 2026.10.1 and subclass WebScraper.

The crawl runs in this order:

1. Start at /jobs/page-1.html and follow the rel="next" links through page 6.
2. Open every job linked from a listing page.
3. Write one line per job to output/jobs.jsonl.

A line holds the job id, title, company, location, salary, posted date and a closed flag.

The crawler also follows these rules:

- It requests nothing outside localhost:5481, and at most one page every 250 ms.
- It obeys robots.txt, and its user agent is HarborJobsCrawler/1.0.
- IronWebScraper's working directory is output/.
- Pages go into IronWebScraper's web cache, so a restart doesn't download them again.
- The crawl gets an id, so a stopped run can start again under that id.
- A --stop-after N option stops the crawl after N jobs, for testing restarts.

Program.cs reads IRONWEBSCRAPER_LICENSE_KEY and sets IronWebScraper.License.LicenseKey once.
The key stays out of output, logs and files. Don't list environment variables either.

The Implementation Plan should answer two questions:

- Where on disk do the cache and the saved crawl state go?
- What happens to queued requests when a crawl stops?

Once the plan is done, build the crawler and run one full crawl.
Tell me how many lines output/jobs.jsonl ends up with.
Text

IronWebScraper ne lit pas IRONWEBSCRAPER_LICENSE_KEY par lui-même, donc l'invite doit faire en sorte que Program.cs assigne License.LicenseKey à partir de celui-ci. Le guide de la clé de licence décrit les autres façons d'appliquer la clé.



Qu'est-ce que Google Antigravity, et en quoi est-il différent d'un assistant de chat?

Selon la présentation de Google, l'application Antigravity est une application de bureau autonome pour lancer et inspecter des équipes d'agents d'IA. Ses agents retournent des Artefacts, tels qu'un Plan de mise en œuvre, une Démonstration et des captures d'écran, pour révision à des jalons clés.

Le guide des assistants de codage AI explique pourquoi une tâche qui ajoute les noms de paquet IronWebScraper exactement. Il liste également les fichiers de documentation d'IronWebScraper pour les agents et inclut un test d'acceptation en une seule invite.

Que devriez-vous vérifier dans le plan, les modifications du code et le guide pas-à-pas ?

Le plan doit placer le cache web et l'état du parcours enregistré sous le répertoire de travail, et il doit indiquer qu'un arrêt laisse les requêtes en file d'attente listées dans l'état enregistré.

Dans les modifications de code, cherchez la réflexion. Le test effectué a arrêté un parcours et lu plus tard des pages mises en cache en appelant des membres IronWebScraper non publics par réflexion, avec 13 utilisations de BindingFlags.NonPublic après la première invite et 9 à la fin. Ces membres sont absents de la référence API et portent des noms obfusqués, alors demandez l'API publique et confirmez chaque membre dans la référence API.

La Démonstration doit contenir une capture d'écran de chaque page d'emploi que le navigateur a ouverte. L'application Antigravity stocke chaque capture d'écran comme un artefact d'image qui accepte les commentaires. Dans le CLI, une invite qui nomme un dossier, tel que artefacts/shots, conserve les captures d'écran dans le référentiel.

Comment vérifiez-vous les enregistrements par rapport au panneau dans un navigateur ?

/browser Check the crawl against the board as a reader sees it.

Delete output/, cache included, and run the crawler once with no options. Then, in the browser:

1. Open http://localhost:5481/jobs/page-1.html and go through all six listing pages.
2. Count the job cards on each page.
3. Open J-1004, J-1012, J-1025, J-1047 and J-1058, and save a screenshot of each in artifacts/shots.
4. Note every field as the page displays it.

Put two tables in the Walkthrough and in artifacts/browser-check.md:

- job cards on the board against lines in output/jobs.jsonl
- one row per field of those five jobs, with the page value, the record value and a match column

If something differs, trace it in the crawler code before editing.
Then fix it, delete output/, crawl again and add both tables a second time.
Tell me what differed and what you changed.
Text

Le panneau contient 60 emplois répartis sur six pages d'annonces. Sept annonces ont été modifiées après publication, et chacune conserve son ancien salaire dans un élément caché avant le salaire affiché par la page. J-1004, J-1012 et J-1047 en font partie. Un robot d'exploration qui lit le premier élément dd.salary enregistre l'ancienne valeur, tandis que le navigateur affiche la nouvelle.

La page des emplois @@@Harbor pour J-1004, un rôle d'Agent de support client chez Saltmarsh Bistro, avec son salaire affiché@

J-1004 tel que capturé par le sous-agent /browser dans le test de fonctionnement.

Sortie

Le fichier ci-dessous est le jobs.jsonl que le parcours a écrit après la comparaison avec le navigateur, inchangé.

Télécharger jobs.jsonl

60 enregistrements d'emplois du tableau de test, un objet JSON par ligne, avec le salaire affiché pour J-1004.

Que conservent le cache web et l'état enregistré ?

EnableWebCache écrit un fichier .webcache par URL dans le dossier WebCache du répertoire de travail. Pour les 66 pages du panneau de test, la sonde a mesuré 66 fichiers et 32 341 octets. Une relance n'a pas fait de demande au panneau et s'est terminée en 4,6 secondes au lieu de 9,4. Le drapeau CretaedFromWebCache, écrit de cette manière dans l'API, était vrai pour chaque réponse.

Le cache ne détecte pas les changements sur le site. Après que le panneau a ajouté deux emplois et modifié un salaire, une relance à partir du cache n'a pas fait de demande et a écrit les anciennes annonces. EnableWebCache avec un TimeSpan limite cela, et avec une expiration de 15 secondes, une relance 20 secondes plus tard a récupéré à nouveau les 66 pages.

Start avec un identifiant de parcours écrit deux fichiers dans le dossier SavedState, l'un listant chaque requête en file d'attente et l'autre listant les requêtes qui ont reçu une réponse. Les deux fichiers existaient après un parcours qui a duré 6 secondes, bien que la documentation XML décrive un enregistrement toutes les cinq minutes. Un identifiant de parcours terminé redémarré n'a fait qu'une seule requête et n'a rien écrit, donc un travail quotidien qui réutilise un identifiant ne collecte pas de nouveaux emplois.

ScrapeUnique n'a jamais écrit le premier enregistrement que chaque grattoir lui a passé pour un fichier, donc 6 des 6 tests de sonde de 60 emplois ont écrit 59 lignes.

Comment configurez-vous un projet dans lequel Antigravity peut travailler?

What IronWebScraper version does HarborJobs.Crawler.csproj pin? Quote the PackageReference.
Quote the lines that apply the license key as well.
Judge everything from the code, without starting the crawler.

The key handling should meet these rules:

- The crawler's own code takes the key only from IRONWEBSCRAPER_LICENSE_KEY.
- No appsettings file or launch profile contains it.
- Without that variable, the crawler prints one line naming it and exits with code 2.
- A licensing failure is reported by exception type name, never by its message.

If the missing-variable line isn't there, add it to Program.cs and touch nothing else.
For every other rule that fails, tell me the file and line.
Text

Sans clé de licence, IronWebScraper 2026.10.1 lance une LicensingException à partir de Start avant que Init ne fonctionne. Le type d'exception n'est pas public, donc catch (LicensingException) échoue à compiler avec CS0122 et un gestionnaire doit faire correspondre le type par nom.

ObeyRobotsDotTxt lit robots.txt uniquement à partir du port par défaut, de sorte que l'agent du test a ajouté le chemin interdit du panneau à BannedUrls.

Comment sauvegardez-vous les règles de parcours pour les tâches ultérieures ?

Lorsque la comparaison avec le navigateur réussit, enregistrez les décisions de la session en tant que règles. Selon la documentation des règles d'Antigravity, le CLI lit AGENTS.md, GEMINI.md et .agents/rules depuis la racine du dépôt et depuis des sous-répertoires. La commande /learn condense les corrections de la session en règles persistantes.

/learn Write down what this session settled, in AGENTS.md at the repo root.
Use the heading "Crawling Harbor Jobs" and cover these points:

- the board URL, the 250 ms limit, robots.txt and the user agent
- the folders for the cache and the crawl state, and when to delete them
- which selector gives the salary the page displays
- that the key comes only from IRONWEBSCRAPER_LICENSE_KEY and is never printed or stored
- that no command lists environment variables
- that a crawl is finished once the browser comparison matches

Show me AGENTS.md when it's written.
Text

Que se passe-t-il lorsqu'un parcours s'arrête à mi-chemin ?

Stop ne termine pas un parcours de manière propre dans IronWebScraper 2026.10.1. Son résumé XML qualifie cet arrêt de gracieux et dit que le parcours peut redémarrer sous son identifiant de parcours sans perte de données. Après Stop, appelé à partir d'une méthode d'analyse ou d'un autre fil d'exécution, Start et StartAsync ne sont jamais revenus dans 3 des 3 sonde s, qui ont été terminés après 60 à 150 secondes.

Un redémarrage sous le même identifiant de parcours n'a pas non plus terminé le parcours. Dans 10 redémarrages de sonde après un arrêt à 20 emplois, Start est revenu normalement à chaque fois, et le fichier contenait de 19 à 57 des 60 emplois. Dans les 9 redémarrages dont l'état enregistré a été inspecté par la suite, 1 à 19 requêtes en file d'attente n'avaient toujours pas reçu de réponse.

/plan A crawl that stops halfway must finish on the next start, with every job exactly once.
Write the Implementation Plan first, and wait until I approve it before you edit any file.

After I approve, measure a restart before you fix anything:

1. Delete output/.
2. Run the crawler with --stop-after 20.
3. Run it again with no options.
4. Count the lines in output/jobs.jsonl, the repeated ids and the ids missing from J-1001 to J-1060.
5. Have the crawler log the pages each run took from the board and from the cache.
6. Write those counts to output/run-counts.txt.

Repeat steps 1 to 6 three times. Treat a run still going after two minutes as hung, and kill it.
Then fix every cause you found, keep the web cache, and do the three restarts again.
Add what the restarts showed to AGENTS.md.

Then tell me:

- the counts for each run, before and after the fix
- what output/SavedState contained after each stop, or that the fix no longer uses it
Text

Cet exemple utilise uniquement l'API publique d'IronWebScraper et compile avec IronWebScraper 2026.10.1. Dans trois cycles d'arrêt et de redémarrage contre le tableau de test, il a demandé 22 pages jusqu'à l'arrêt et les 44 restantes au redémarrage, et son fichier a contenu une fois chacun des 60 emplois. Après le troisième cycle, le dossier de sortie contenait jobs.jsonl et 66 pages mises en cache dans WebCache, et l'exemple ne supprime aucun d'eux.

using System.Text.Json;
using IronWebScraper;

var key = Environment.GetEnvironmentVariable("IRONWEBSCRAPER_LICENSE_KEY");
if (string.IsNullOrWhiteSpace(key))
{
    Console.WriteLine("Missing required environment variable: IRONWEBSCRAPER_LICENSE_KEY");
    return 2;
}
License.LicenseKey = key;

int stopAfter = args.Length == 2 && args[0] == "--stop-after" ? int.Parse(args[1]) : 0;
new HarborJobsScraper(stopAfter).Start();
return 0;

public sealed class HarborJobsScraper(int stopAfter) : WebScraper
{
    private const string Board = "http://localhost:5481";
    private readonly object _fileLock = new();
    private readonly HashSet<string> _written = new();
    private int _jobsThisRun;

    public override void Init()
    {
        WorkingDirectory = "output";
        RateLimitPerHost = TimeSpan.FromMilliseconds(250);
        ObeyRobotsDotTxt = true;
        AllowedDomains.Add("localhost");
        Identities.Add(new HttpIdentity { UserAgent = "HarborJobsCrawler/1.0" });

        // Pages fetched before a stop come back from output/WebCache on the next start.
        EnableWebCache(TimeSpan.FromHours(12));

        string jobsFile = Path.Combine(WorkingDirectory, "jobs.jsonl");
        if (File.Exists(jobsFile))
        {
            foreach (var line in File.ReadLines(jobsFile))
            {
                _written.Add(JsonDocument.Parse(line).RootElement.GetProperty("id").GetString()!);
            }
        }

        Request(Board + "/jobs/page-1.html", Parse);
    }

    public override void Parse(Response response)
    {
        foreach (var link in response.Css("article.job-card h2 a"))
        {
            Request(response.ToAbsoluteUrl(link.Attributes["href"]), ParseJob);
        }
        foreach (var next in response.Css("a[rel=next]"))
        {
            Request(response.ToAbsoluteUrl(next.Attributes["href"]), Parse);
        }
    }

    public void ParseJob(Response response)
    {
        // The page carries an old salary in a hidden element ahead of the one it displays.
        var salary = response.Css("dd.salary").Last(n => n.GetAttribute("style") is not { } s || !s.Contains("display:none"));
        var job = new
        {
            id = response.Css("dd.job-id")[0].TextContentClean,
            title = response.Css("h1.job-title")[0].TextContentClean,
            company = response.Css("dd.company")[0].TextContentClean,
            location = response.Css("dd.location")[0].TextContentClean,
            salary = salary.TextContentClean,
            postedDate = response.Css("time")[0].GetAttribute("datetime"),
            closed = response.CssExists("p.closed"),
        };

        lock (_fileLock)
        {
            // ScrapeUnique drops the first record of each process, so the crawler writes the file itself.
            if (_written.Add(job.id))
            {
                File.AppendAllText(Path.Combine(WorkingDirectory, "jobs.jsonl"), JsonSerializer.Serialize(job) + "\n");
            }
            if (stopAfter > 0 && ++_jobsThisRun >= stopAfter)
            {
                // Start never returns after Stop() in 2026.10.1, so a test stop ends the process.
                Environment.Exit(0);
            }
        }
    }
}
C#

Quand devriez-vous dépêcher plus d'un agent ?

Harbor Jobs adds jobs every morning, and the crawler is scheduled once a day.
Divide the next part between two agents.

Agent A builds an xUnit project, HarborJobs.Crawler.Tests:

- Save the J-1004, J-1012, J-1021, J-1047 and J-1061 pages from today's board into TestData.
- Test the record each saved page produces, salary and closed flag included.
- The tests read only those files and send no request.
- Keep the test project out of the crawler's compile items.
- Run it with dotnet test HarborJobs.Crawler.Tests.

If the tests fail, stop there and tell me why.
Otherwise Agent B takes these steps:

1. Run the crawler with today's command and the existing output/ folder, as tomorrow's run would.
2. Use /browser to open page 1 of the board and each job it links to.
3. Check that every one of those jobs has a line in jobs.jsonl with the same values.

If the board and the file disagree, explain why before changing anything.
A restart on the same day still reads the cache, and the fix has to keep that.
Save screenshots in artifacts/shots-day2.
Write how many page 1 jobs matched before and after to artifacts/day2-check.md.

Tell me what each agent found.
Text

Avant cette invite, le tableau de test était passé aux annonces du lendemain matin, avec deux nouveaux emplois en haut de la page 1, un salaire modifié et un emploi fermé.

Veuillez noter: La présentation de Google décrit des sous-agents simultanés qui fonctionnent à travers des arborescences Git isolées. Lisez chaque conversation de sous-agent avant de fusionner son travail.

Qu'est-ce que les messages ont produit lors d'une réelle exécution ?

Les six invites ont fonctionné sans surveillance dans une conversation principale du CLI Antigravity, avec des invites de permission sautées. Chaque chiffre ci-dessous provient du journal de synchronisation et des vérifications indépendantes des validations de l'exécution, du journal des requêtes et des relances.

  • Avant la première invite, le dépôt contenait un projet de console qui ne faisait qu'afficher son nom.
  • Lors de la planification, l'agent a récupéré les pages d'emploi avec ses propres requêtes PowerShell et trouvé les salaires cachés.
  • La première exploration complète a écrit 60 lignes, et les 60 ont correspondu au tableau.
  • Le premier test de l'option d'arrêt n'est jamais sorti et a été terminé par l'opérateur après 23 minutes.
  • Dans la première invite, 64 des 273 intervalles entre les demandes de robot d'exploration étaient inférieurs à 240 ms, le plus court étant de 8 ms.
  • À partir de la deuxième invite, aucun intervalle de robot d'exploration n'était inférieur à 292 ms.
  • La comparaison du navigateur a compté 60 cartes d'emploi contre 60 lignes et n'a trouvé aucune différence de champ, donc son étape de correction n'avait rien à changer.
  • Le Chrome du sous-agent navigateur a demandé 125 pages sous /apply/, que robots.txt interdit, et le robot d'exploration n'en a demandé aucune.
  • Sans la variable clé, le robot d'exploration final a imprimé une ligne la nommant et s'est arrêté avec le code 2.
  • Avec une clé invalide, il s'est terminé par une LicensingException non gérée, un échec que l'invite d'installation a rapporté et laissé en place.
  • La correction de redémarrage a laissé tomber l'identifiant du parcours et a gardé sa propre file d'attente de pages en attente.
  • Dans trois cycles indépendants d'arrêt et de redémarrage, le robot d'exploration final a écrit une fois les 60 emplois, avec 23 demandes avant chaque arrêt et 44 après.
  • Sur le tableau du jour suivant, le robot d'exploration de la première invite n'a fait aucune demande et a manqué les deux nouveaux emplois.
  • Le fichier de ce robot d'exploration correspondait à 7 des 10 emplois sur la nouvelle page 1.
  • Après la correction de l'Agent B, le robot d'exploration final a trouvé les 60 emplois sur ce tableau.
  • Les cinq tests de l'Agent A ont passé sans contacter le tableau.
  • Certaines étapes ont été exécutées différemment de la page. Les 57,2 minutes de la première invite comprenaient l'attente du test d'arrêt bloqué. Chaque invite à partir de la deuxième s'est terminée avec un état agy d'ERREUR, pour un appel de fonction malformé, après sa réponse complète. L'Agent A a fonctionné en tant que sous-agent distinct, et la conversation principale a exécuté les étapes de l'Agent B avec un sous-agent navigateur. Le sous-agent /browser a utilisé un Chrome sans tête que l'exécution a démarré, car le CLI recherche le fichier de port DevTools de Chrome dans le profil de l'utilisateur. Le robot d'exploration final a effacé son cache après une exploration complète, donc une relance après achèvement a demandé à nouveau chaque page.

ChatGPT Codex lit ses règles en vigueur depuis AGENTS.md, comme le fait ce guide, et transmet les parties nommées d'une tâche à des agents explorateurs et travailleurs. GitHub Copilot teste également un robot d'exploration par rapport aux pages enregistrées sans demande au site. La version d'Antigravity, le modèle, le temps d'exécution et la machine de test sont enregistrés dans le journal des exécutions partagées.


Dépannage


Des questions ?

Si vous avez des questions, contactez support@ironsoftware.com

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.

Lire la suite

Prêt à commencer ?

Téléchargements NuGet 150,061Version :2026.11tout juste publié