strot

Die interne API jeder Website mit natürlicher Sprache reverse-engineeren

---

Das Problem

Moderne Websites laden Daten durch versteckte AJAX-Aufrufe:

• Die Daten sind nicht im HTML – sie werden über interne APIs abgerufen
• Sie müssen Netzwerkanfragen manuell inspizieren
• Komplexe Paginierungslogik, die in JavaScript versteckt ist
• APIs ändern häufig Endpunkte und Parameter

Die Lösung

Strot analysiert Websites und findet ihre internen API-Aufrufe für Sie.

Was Strot tatsächlich macht:

1. Analysiert die Webseite, um zu verstehen, welche Daten Sie möchten
2. Erfasst die AJAX-Anfrage, die diese Daten abruft
3. Erkennt alle Parameter – Paginierung (limit/offset, Cursor, Seitennummern) UND dynamische Parameter (Sortierung, Filterung, Suche)
4. Generiert Extraktionscode, um die JSON-Antwort zu parsen
5. Gibt eine Quelle (Source) zurück, die die eigenen API-Aufrufe der Website mit vollständiger Parametersteuerung nachbildet

🐳 Jetzt ausprobieren – Keine Einrichtung erforderlich!

Holen Sie sich das volle Strot-Erlebnis (Web-UI + API) sofort:

Verwendung des Patchright-Browsers

docker run -d --name browser-server -p 5678:5678 synacktra/patchright-headless-server
STROT_ANTHROPIC_API_KEY=sk-ant-apiXXXXXX \
  docker compose -f https://raw.githubusercontent.com/vertexcover-io/strot/refs/heads/main/docker-compose.yml up

Oder mit dem Steel-Browser

STROT_BROWSER_WS_URL=wss://connect.steel.dev?apiKey=ste-XXXXXX STROT_ANTHROPIC_API_KEY=sk-ant-apiXXXXXX \
  docker compose -f https://raw.githubusercontent.com/vertexcover-io/strot/refs/heads/main/docker-compose.yml up

Dann besuchen Sie:

• 🌐 Web-Dashboard: http://localhost:3000 – Visuelle Oberfläche zum Analysieren von Websites
• 🔌 REST-API: http://localhost:1337 – Programmgesteuerter Zugriff

🐍 Python-Bibliothek

Installation

pip install strot

Oder mit uv:

uv pip install strot

Beispiel 1: Reverse-Engineering einer Bewertungs-API

import strot
import asyncio
from pydantic import BaseModel

class Review(BaseModel):
    title: str | None = None
    username: str | None = None
    rating: float | None = None
    comment: str | None = None
    date: str | None = None

async def get_reviews():
    # Strot entdeckt die interne API, die Bewertungen lädt
    source = await strot.analyze(
        url="https://www.getcleanpeople.com/product/fresh-clean-laundry-detergent/",
        query="Customer reviews with ratings and comments",
        output_schema=Review,
        code_executor="e2b" # Standardmäßig "unsafe"
    )

    # Verwenden Sie denselben API-Aufruf, den die Website verwendet, mit vollständiger Parametersteuerung
    async for reviews in source.generate_data(limit=500, offset=100, sortBy="date desc"):
        for review in reviews:
            print(f"{review['rating']}⭐ von {review['username']}: {review['comment']}")

if __name__ == "__main__":
    asyncio.run(get_reviews())

Beispiel 2: Erfassung einer Produktlisten-API

import strot
import asyncio
from pydantic import BaseModel

class Product(BaseModel):
    name: str | None = None
    price: float | None = None
    rating: float | None = None
    availability: str | None = None
    description: str | None = None

async def get_products():
    # Strot findet den AJAX-Endpunkt, der Produktlisten lädt
    source = await strot.analyze(
        url="https://blinkit.com/cn/fresh-vegetables/cid/1487/1489",
        query="Listed products with names and prices.",
        output_schema=Product
    )

    # Legen Sie einen gewünschten Code-Executor in der Quelle fest
    source.set_code_executor("e2b")

    # Greifen Sie auf alle Produkte mit benutzerdefinierten Filtern und Sortierung zu
    async for products in source.generate_data(limit=100, offset=0, category="vegetables", sortBy="price"):
        for product in products:
            print(f"{product['name']}: ${product['price']} ({product['rating']}⭐)")

if __name__ == "__main__":
    asyncio.run(get_products())

🔌 MCP-Server

Strot bietet einen MCP-Server (Model Context Protocol), der es MCP-Clients wie Claude ermöglicht, Websites direkt zu analysieren und ihre internen APIs zu entdecken.

Einrichtung

git clone https://github.com/vertexcover-io/strot.git
cd strot && uv sync --group mcp

Umgebungsvariablen setzen:

export STROT_ANTHROPIC_API_KEY=sk-ant-apiXXXXXX
export STROT_BROWSER_MODE_OR_WS_URL=headless  # oder 'headed' oder ws://browser-url

Wenn Sie einen gehosteten Browser verwenden möchten, können Sie Folgendes tun:

Führen Sie einen kopflosen Server in Docker aus

docker run -d --name browser-server -p 5678:5678 synacktra/patchright-headless-server
export STROT_BROWSER_MODE_OR_WS_URL=ws://localhost:5678/patchright

Oder verbinden Sie sich mit einem entfernten Browser-Server:

export STROT_BROWSER_MODE_OR_WS_URL=wss://...

Verwendung

$ uv run strotmcp
Usage: strotmcp COMMAND

╭─ Commands ─────────────────────────────────────────────╮
│ http             Start an http server.                 │
│ sse              Start an sse server.                  │
│ stdio            Start a stdio server.                 │
│ streamable-http  Start a streamable http server.       │
╰────────────────────────────────────────────────────────╯

Mit Claude Code

• stdio-Transport

  claude mcp add strot-mcp "uv run strotmcp stdio" --transport stdio \
    --env STROT_ANTHROPIC_API_KEY=$STROT_ANTHROPIC_API_KEY STROT_BROWSER_MODE_OR_WS_URL=$STROT_BROWSER_MODE_OR_WS_URL
  

• sse-, http- und streamable-http-Transporte

  Starten Sie den MCP-Server mit dem gewünschten Transport in einem separaten Terminal:

  uv run strotmcp sse --port 8888
  # uv run strotmcp http --host 0.0.0.0
  # uv run strotmcp streamable-http --host 127.0.0.1 --port 8777
  

  Fügen Sie den MCP-Server zu Claude hinzu:

  claude mcp add strot-mcp http://127.0.0.1:8888/sse --transport sse
  

🧪 Evaluierung

Testen und validieren Sie die Analysegenauigkeit von Strot auf verschiedenen Websites und einzelnen Komponenten. Das Evaluierungssystem unterstützt fünf Eingabetypen:

• existierende Aufträge (bewerten Sie abgeschlossene Aufträge anhand ihrer ID),
• neue Aufträge (erstellen und bewerten Sie vollständige Analyseaufgaben),
• Anforderungserkennung (testen Sie URL- und Abfragekombinationen),
• Parametenerkennung (testen Sie die Analyse einzelner Anforderungsparameter – sowohl Paginierung als auch dynamische Parameter),
• strukturierte Extraktion (testen Sie die Antwortanalyse mit bestimmten Schemata).

Die Ergebnisse werden mit den erwarteten Ergebnissen verglichen, wobei Metriken wie Quell-URL-Übereinstimmung, Paginierungsschlüsselerkennung, dynamische Parametenerkennung und Genauigkeit der Entitätsanzahl verfolgt werden. Alle Evaluierungen und ihre detaillierten Analyseschritte werden in Airtable gespeichert.

Einrichtung

git clone https://github.com/vertexcover-io/strot.git
cd strot && uv sync --group eval

Airtable einrichten

1. Erstellen Sie eine neue Airtable-Basis:

   • Gehen Sie zu Workspaces
   • Klicken Sie auf die Schaltfläche Create in Ihrem gewünschten Workspace
   • Wählen Sie Build an app on your own
   • Kopieren Sie die Basis-ID aus der URL (z. B. appXXXXXXXXXXXXXX)

2. Erstellen Sie einen persönlichen Zugriffstoken: