Wie man IronWebScraper mit Google Antigravity verwendet

Curtis Chau
Curtis Chau
Aktualisiert: 26. Oktober 2026

Ein Team für Rekrutierungsanalysen sammelt jeden Morgen jede Anzeige von einer regionalen Jobbörse. Ein Crawl von ein paar hundert Seiten kann auf halbem Weg gestoppt werden, wenn ein Server neu startet, ein Laptop schläft oder jemand Strg+C drückt. Wenn der Crawler neu startet, muss er die verbleibenden Seiten abschließen, ohne die fertigen doppelt herunterzuladen und ohne einen Job doppelt zu schreiben. Ein Crawl kann auch ohne Fehler enden und dennoch ein Gehalt aufzeichnen, das die Seite nicht mehr anzeigt. Keiner der Fehler erscheint in einem Konsolenprotokoll.

Google Antigravity kann den Crawl mit der Seite abgleichen, wie ein Arbeitssucher sie sieht. Sein /browser Befehl startet einen Browser-Subagenten, der jede Seite öffnet und einen Screenshot erstellt. IronWebScraper hält einen Web-Cache und kann einen Crawl unter einer Crawl-ID neu starten. Dies wird im Tutorial zu erweiterten Webscraping-Funktionen behandelt. Diese Anleitung erstellt einen Jobbörsen-Crawler mit beiden Tools und testet diesen gegen eine lokale Kopie eines Boards, dessen 60 Anzeigen im Voraus bekannt sind.

Diese Anleitung richtet sich an Entwickler, die AI-Agenten verwenden, um .NET-Crawler zu schreiben. Jeder Crawl darin zielt auf ein Test-Board auf localhost ab und behandelt nicht das Crawlen von Seiten, die Sie nicht betreiben.

Schnellstart
NuGetMit NuGet installieren

PM > Install-Package IronWebScraper

Installieren Sie IronWebScraper, indem Sie den obigen Befehl in der NuGet Packet Manager-Konsole ausführen, oder suchen Sie das Paket im NuGet Paket Manager.

Öffnen Sie das HarborJobs.Crawler-Projekt in Antigravity und beschreiben Sie den Crawl.

/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 liest IRONWEBSCRAPER_LICENSE_KEY nicht von alleine, daher weist der Prompt Program.cs an, License.LicenseKey daraus zuweisen. Der Lizenzschlüssel-Leitfaden beschreibt die anderen Möglichkeiten, den Schlüssel anzuwenden.



Was ist Google Antigravity und wie unterscheidet es sich von einem Chat-Assistenten?

Laut Googles Übersicht ist die Antigravity App eine eigenständige Desktop-Anwendung zum Starten und Inspizieren von Teams aus AI-Agenten. Ihre Agenten liefern Artefakte, wie einen Implementierungsplan, ein Walkthrough und Screenshots, die bei wichtigen Meilensteinen überprüft werden.

Der Leitfaden zu AI-Coding-Assistenten erklärt, warum eine Aufgabe die Paketnamen genau IronWebScraper hinzufügt. Er listet auch die Dokumentationsdateien von IronWebScraper für Agenten auf und enthält einen einzigen Prompt-Akzeptanztest.

Was sollten Sie im Plan, den Codeänderungen und der Anleitung überprüfen?

Der Plan sollte den Web-Cache und den gespeicherten Crawl-Status unter dem Arbeitsverzeichnis ablegen und sagen, dass ein Stopp die in der gespeicherten State aufgeführten Anfragen in der Warteschlange belässt.

Suchen Sie in den Codeänderungen nach Reflexion. Der Testrun stoppte einen Crawl und las später gecachte Seiten, indem er nicht-öffentliche IronWebScraper-Mitglieder durch Reflexion aufrief, mit 13 Verwendungen von BindingFlags.NonPublic nach dem ersten Prompt und 9 am Ende. Diese Mitglieder fehlen in der API-Referenz und tragen verschleierte Namen, daher fragen Sie nach der öffentlichen API und bestätigen Sie jedes Mitglied in der API-Referenz.

Das Walkthrough sollte einen Screenshot von jeder Jobseite enthalten, die der Browser geöffnet hat. Die Antigravity App speichert jeden Screenshot als Bildartefakt, das Kommentare akzeptiert. In der CLI bewahrt ein Prompt, der einen Ordner benennt, wie artefakte/shots, die Screenshots im Repository.

Wie überprüfen Sie die Aufzeichnungen gegen das Board in einem Browser?

/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

Das Board hält 60 Jobs auf sechs Listen-Seiten. Sieben Listings wurden nach der Veröffentlichung bearbeitet, und jedes behält sein altes Gehalt in einem versteckten Element vor dem Gehalt, das die Seite anzeigt. J-1004, J-1012 und J-1047 gehören dazu. Ein Crawler, der das erste dd.salary-Element liest, protokolliert die alte Zahl, während der Browser die neue anzeigt.

Harbor Jobs-Seite für J-1004, eine Kunden-Support-Agentenrolle bei Saltmarsh Bistro, mit dem angezeigten Gehalt

J-1004, wie ihn der /browser-Subagent im Testrun erfasst hat.

Ausgabe

Die Datei unten ist das jobs.jsonl, das der Crawl nach dem Browser-Vergleich geschrieben hat, unverändert.

Download jobs.jsonl

60 Jobdatensätze vom Test-Board, ein JSON-Objekt pro Zeile, mit dem angezeigten Gehalt für J-1004.

Was behalten der Webcache und der gespeicherte Zustand bei?

EnableWebCache schreibt eine .webcache-Datei pro URL in den WebCache-Ordner des Arbeitsverzeichnisses. Für die 66 Seiten des Test-Boards maß die Sonde 66 Dateien und 32.341 Bytes. Ein erneuter Lauf stellte keine Anfrage an das Board und endete in 4,6 Sekunden statt 9,4. Das CretaedFromWebCache-Flag, auf diese Weise in der API geschrieben, war bei jeder Antwort wahr.

Der Cache erkennt keine Änderungen auf der Seite. Nachdem das Board zwei Jobs hinzugefügt und ein Gehalt geändert hatte, machte ein gecachter erneuter Lauf keine Anfrage und schrieb die alten Listings. EnableWebCache mit einem TimeSpan begrenzt dies, und mit einem Ablauf von 15 Sekunden fetchte ein erneuter Lauf 20 Sekunden später alle 66 Seiten erneut.

Start mit einer Crawl-ID schreibt zwei Dateien in den SavedState-Ordner, eine listet jede Anfrage in der Warteschlange auf und eine listet die Anfragen auf, die eine Antwort erhielten. Beide Dateien existierten nach einem Crawl, der 6 Sekunden lief, obwohl die XML-Dokumentation eine Speicherung alle fünf Minuten beschreibt. Eine erneut begonnene Crawl-ID machte eine Anfrage und schrieb nichts, daher sammelt ein täglicher Job, der eine ID wiederverwendet, keine neuen Jobs.

ScrapeUnique hat nie den ersten Datensatz geschrieben, den jeder Scraper ihm für eine Datei übergab, daher schrieben 6 von 6 Sonden-Crawls von 60 Jobs 59 Zeilen.

Wie richtet man ein Projekt ein, in dem Antigravity arbeiten kann?

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

Ohne einen Lizenzschlüssel wirft IronWebScraper 2026.10.1 eine LicensingException aus Start, bevor Init ausgeführt wird. Der Ausnahme-Typ ist nicht öffentlich, daher schlägt catch (LicensingException) mit CS0122 fehl und ein Handler muss den Typ nach Namen abgleichen.

ObeyRobotsDotTxt liest robots.txt nur vom Standardport, daher fügte der Agent des Testrun den unerlaubten Pfad des Boards zu BannedUrls hinzu.

Wie speichern Sie die Crawl-Regeln für spätere Aufgaben?

Wenn der Browser-Vergleich besteht, zeichnen Sie die Entscheidungen der Sitzung als Regeln auf. Laut der Regeln-Dokumentation von Antigravity liest die CLI AGENTS.md, GEMINI.md und .agents/rules aus dem Repository-Stamm und aus Unterverzeichnissen. Der /learn-Befehl komprimiert Korrekturen aus der Sitzung in dauerhafte Regeln.

/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

Was passiert, wenn ein Crawl auf halbem Weg stoppt?

Stop beendet einen Crawl in IronWebScraper 2026.10.1 nicht sauber. Seine XML-Zusammenfassung nennt den Stopp freundlich und sagt, der Crawl könne unter seiner Crawl-ID ohne Datenverlust neu gestartet werden. Nach Stop, aufgerufen aus einer Parse-Methode oder einem anderen Thread, kehrten Start und StartAsync in 3 von 3 Sondierungen nie zurück, die nach 60 bis 150 Sekunden beendet wurden.

Ein Neustart unter derselben Crawl-ID beendete den Crawl ebenfalls nicht. Bei 10 Sonden-Neustarts nach einem Stopp bei 20 Jobs kehrte Start jedes Mal normal zurück, und die Datei enthielt 19 bis 57 der 60 Jobs. In den 9 Neustarts, deren gespeicherter Zustand danach inspiziert wurde, hatten 1 bis 19 angeforderte Anfragen noch keine Antwort.

/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

Dieses Beispiel verwendet nur IronWebScrapers öffentliche API und kompiliert mit IronWebScraper 2026.10.1. In drei Stopp- und Neustartzyklen gegen das Test-Board forderte es 22 Seiten bis zum Stopp und die verbleibenden 44 beim Neustart, und seine Datei enthielt jeden der 60 Jobs einmal. Nach dem dritten Zyklus enthielt der Ausgabefolder jobs.jsonl und 66 gecachte Seiten in WebCache, und das Beispiel löscht keine davon.

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#

Wann sollten Sie mehr als einen Agenten entsenden?

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

Vor diesem Prompt wechselte das Test-Board zu den Anzeigen des nächsten Morgens, mit zwei neuen Jobs an der Spitze von Seite 1, einem geänderten Gehalt und einem geschlossenen Job.

Bitte beachten Sie: Googles Übersicht beschreibt gleichzeitige Teilagenten, die in isolierten Git-Arbeitsbereichen arbeiten. Lesen Sie das Gespräch jedes Teilagenten, bevor Sie seine Arbeit zusammenführen.

Was haben die Aufforderungen in einem realen Lauf erzeugt?

Alle sechs Prompts liefen unbeaufsichtigt in einem Haupt-Antigravity CLI-Gespräch, wobei Erlaubnisanfragen übersprungen wurden. Alle untenstehenden Zahlen stammen aus dem Timing-Protokoll und unabhängigen Überprüfungen der Commits des Laufes, Anforderungsprotokoll und erneuten Läufen.

  • Vor dem ersten Prompt enthielt das Repository ein Konsolenprojekt, das nur seinen Namen druckte.
  • Während der Planung rief der Agent die Jobseiten mit eigenen PowerShell-Anfragen ab und fand die versteckten Gehälter.
  • Der erste vollständige Crawl schrieb 60 Zeilen und alle 60 stimmten mit dem Board überein.
  • Der erste Test der Stopp-Option beendete nie und wurde nach 23 Minuten vom Operator beendet.
  • Im ersten Prompt lagen 64 von 273 Intervallen zwischen den Crawler-Anfragen unter 240 ms, das kürzeste bei 8 ms.
  • Ab dem zweiten Prompt fiel kein Crawler-Intervall unter 292 ms.
  • Der Browser-Vergleich zählte 60 Jobkarten gegen 60 Zeilen und stellte keinen Unterschied im Feld fest, sodass sein Fix-Schritt nichts zu ändern hatte.
  • Der Chrome des Browser-Subagenten forderte 125 Seiten unter /apply/an, die robots.txt nicht erlaubt, und der Crawler forderte keine an.
  • Ohne die Schlüsselvariable druckte der letzte Crawler eine Zeile, die ihn benannte, und beendete mit Code 2.
  • Mit einem ungültigen Schlüssel endete es mit einer nicht behandelten LicensingException, einem Fehler, den der Setup-Prompt meldete und im Platz ließ.
  • Die Neustartkorrektur ließ die Crawl-ID fallen und behielt ihre eigene Warteschlange ausstehenden Seiten.
  • In drei unabhängigen Stopp-und-Neustartzyklen schrieb der letzte Crawler alle 60 Jobs einmal, mit 23 Anfragen vor jedem Stopp und 44 danach.
  • Auf dem Board des nächsten Tages machte der Crawler des ersten Prompts keine Anfragen und verpasste beide neuen Jobs.
  • Die Datei dieses Crawlers stimmte mit 7 der 10 Jobs auf der neuen Seite 1 überein.
  • Nach der Korrektur von Agent B stimmte der letzte Crawler mit allen 60 Jobs auf diesem Board überein.
  • Agent As fünf Tests bestanden ohne Kontaktierung des Boards.
  • Einige Schritte liefen anders als die Seite. Die 57,2 Minuten des ersten Prompts beinhalteten das Warten auf den hängenden Stopp-Test. Jeder Prompt vom zweiten an endete mit einem agy-Status von ERROR, für einen fehlerhaften Funktionsaufruf, nach vollständiger Antwort. Agent A lief als separater Subagent und das Hauptgespräch lief die Schritte von Agent B mit einem Browser-Subagent. Der /browser-Subagent verwendete einen headless Chrome, den der Lauf startete, da die CLI nach der DevTools-Port-Datei von Chrome im Profil des Benutzers sucht. Der letzte Crawler löschte seinen Cache nach einem vollständigen Crawl, sodass ein erneuter Lauf nach Abschluss jede Seite erneut anforderte.

ChatGPT Codex liest seine ständigen Regeln aus AGENTS.md, wie dieser Leitfaden auch, und übergibt benannte Teile einer Aufgabe an Entdecker- und Arbeiteragenten. GitHub Copilot testet auch einen Crawler gegen gespeicherte Seiten ohne eine Anfrage an die Seite. Antigravitys Version, das Modell, die Laufzeit und die Testmaschine werden im gemeinsamen Laufprotokoll aufgezeichnet.


Fehlerbehebung


Fragen?

Wenn Sie Fragen haben, wenden Sie sich an support@ironsoftware.com.

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

Mehr lesen

Bereit loszulegen?

NuGet-Downloads 150,061Version:2026.11gerade veröffentlicht