scrapebadger-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{scrapebadger_cli-0.6.0 → scrapebadger_cli-0.7.0}/.gitignore

@@ -191,3 +191,6 @@ research/
 # The blog upload dir predates this and is deliberately left as-is.
 apps/portal/public/uploads/support/*
 !apps/portal/public/uploads/support/.gitkeep
+
+# Instagram account pool seed (purchased credentials — never commit)
+scrapers/instagram/.secrets/

{scrapebadger_cli-0.6.0 → scrapebadger_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrapebadger-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: ScrapeBadger CLI — Twitter, Vinted, Google, and Web Scraping from the command line
 Author: ScrapeBadger Team
 License: MIT

{scrapebadger_cli-0.6.0 → scrapebadger_cli-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scrapebadger-cli"
-version = "0.6.0"
+version = "0.7.0"
 description = "ScrapeBadger CLI — Twitter, Vinted, Google, and Web Scraping from the command line"
 requires-python = ">=3.10"
 license = {text = "MIT"}

scrapebadger_cli-0.7.0/src/scrapebadger_cli/commands/apartments.py

@@ -0,0 +1,63 @@
+"""Apartments.com rental-listing commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+
+
+@app.command()
+def search(
+    location: str = typer.Argument(..., help="Location slug, e.g. kansas-city-mo, or a ZIP"),
+    page: int = typer.Option(1, "--page", "-p", help="1-28"),
+    beds: int | None = typer.Option(None, "--beds", help="0=studio, 1-4 bedrooms"),
+    min_price: int | None = typer.Option(None, "--min-price"),
+    max_price: int | None = typer.Option(None, "--max-price"),
+    output: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search rental listings in a location."""
+    params: dict = {"location": location, "page": page}
+    for k, v in (("beds", beds), ("min_price", min_price), ("max_price", max_price)):
+        if v is not None:
+            params[k] = v
+    data = api_get("/v1/apartments/search", params=params)
+    render(data.get("results", data) if isinstance(data, dict) else data, output, fields)
+
+
+@app.command()
+def property(
+    url: str = typer.Argument(..., help="Full apartments.com property URL"),
+    output: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a property with full per-unit pricing and availability."""
+    data = api_get("/v1/apartments/property", params={"url": url})
+    render(data, output, fields)
+
+
+@app.command()
+def units(
+    url: str = typer.Argument(..., help="Full apartments.com property URL"),
+    output: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List just the rentable units for a property — the flattened view."""
+    data = api_get("/v1/apartments/property", params={"url": url})
+    render(data.get("units", []) if isinstance(data, dict) else data, output, fields)
+
+
+@app.command("floor-plans")
+def floor_plans(
+    url: str = typer.Argument(..., help="Full apartments.com property URL"),
+    output: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List a property's floor plans."""
+    data = api_get("/v1/apartments/property", params={"url": url})
+    render(data.get("floor_plans", []) if isinstance(data, dict) else data, output, fields)

scrapebadger_cli-0.7.0/src/scrapebadger_cli/commands/facebook.py

@@ -0,0 +1,271 @@
+"""Facebook pages, groups, posts, search & Marketplace commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+LOCATION = typer.Option("nyc", "--location", "-l", help="Marketplace location slug (e.g. nyc, la)")
+AFTER = typer.Option(None, "--after", help="Pagination cursor (end_cursor from a prior response)")
+
+
+@app.command(name="marketplace-search")
+def marketplace_search(
+    query: str = typer.Argument(..., help="Search keywords"),
+    location: str = LOCATION,
+    min_price: int | None = typer.Option(None, "--min-price"),
+    max_price: int | None = typer.Option(None, "--max-price"),
+    days_since_listed: int | None = typer.Option(
+        None, "--days-since-listed", help="Only listings posted in the last N days"
+    ),
+    sort_by: str | None = typer.Option(
+        None, "--sort-by", help="best_match, price_ascend, price_descend, creation_time_descend"
+    ),
+    item_condition: str | None = typer.Option(
+        None, "--condition", help="new, used_like_new, used_good, used_fair"
+    ),
+    delivery_method: str | None = typer.Option(
+        None, "--delivery", help="local_pick_up or shipping"
+    ),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Facebook Marketplace listings."""
+    data = api_get(
+        "/v1/facebook/marketplace/search",
+        {
+            "query": query,
+            "location": location,
+            "min_price": min_price,
+            "max_price": max_price,
+            "days_since_listed": days_since_listed,
+            "sort_by": sort_by,
+            "item_condition": item_condition,
+            "delivery_method": delivery_method,
+            "after": after,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="marketplace-category")
+def marketplace_category(
+    category: str = typer.Argument(..., help="Category slug (vehicles, electronics, ...)"),
+    location: str = LOCATION,
+    min_price: int | None = typer.Option(None, "--min-price"),
+    max_price: int | None = typer.Option(None, "--max-price"),
+    sort_by: str | None = typer.Option(None, "--sort-by"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Browse Marketplace listings in a category."""
+    data = api_get(
+        f"/v1/facebook/marketplace/category/{category}",
+        {
+            "location": location,
+            "min_price": min_price,
+            "max_price": max_price,
+            "sort_by": sort_by,
+            "after": after,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="marketplace-item")
+def marketplace_item(
+    item_id: str = typer.Argument(..., help="Marketplace item ID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get full detail for a Marketplace listing."""
+    data = api_get(f"/v1/facebook/marketplace/item/{item_id}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def locations(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List common Marketplace location slugs."""
+    data = api_get("/v1/facebook/marketplace/locations")
+    render(data, fmt, fields)
+
+
+@app.command()
+def categories(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List Marketplace category slugs."""
+    data = api_get("/v1/facebook/marketplace/categories")
+    render(data, fmt, fields)
+
+
+@app.command()
+def search(
+    q: str = typer.Argument(..., help="Search query"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Facebook globally (pages, people, groups, posts)."""
+    data = api_get("/v1/facebook/search", {"q": q, "after": after})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-pages")
+def search_pages(
+    q: str = typer.Argument(..., help="Search query"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Facebook Pages."""
+    data = api_get("/v1/facebook/search/pages", {"q": q, "after": after})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-people")
+def search_people(
+    q: str = typer.Argument(..., help="Search query"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Facebook profiles."""
+    data = api_get("/v1/facebook/search/people", {"q": q, "after": after})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-groups")
+def search_groups(
+    q: str = typer.Argument(..., help="Search query"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Facebook groups."""
+    data = api_get("/v1/facebook/search/groups", {"q": q, "after": after})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-posts")
+def search_posts(
+    q: str = typer.Argument(..., help="Search query"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search public Facebook posts."""
+    data = api_get("/v1/facebook/search/posts", {"q": q, "after": after})
+    render(data, fmt, fields)
+
+
+@app.command()
+def page(
+    identifier: str = typer.Argument(..., help="Page username or numeric page ID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Facebook Page's profile."""
+    data = api_get(f"/v1/facebook/pages/{identifier}")
+    render(data, fmt, fields)
+
+
+@app.command(name="page-posts")
+def page_posts(
+    identifier: str = typer.Argument(..., help="Page username or numeric page ID"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Facebook Page's timeline posts."""
+    data = api_get(f"/v1/facebook/pages/{identifier}/posts", {"after": after})
+    render(data, fmt, fields)
+
+
+@app.command()
+def profile(
+    identifier: str = typer.Argument(..., help="Profile username or numeric profile ID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Facebook profile's details."""
+    data = api_get(f"/v1/facebook/profiles/{identifier}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def group(
+    group_id: str = typer.Argument(..., help="Group ID or vanity slug"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Facebook group's details."""
+    data = api_get(f"/v1/facebook/groups/{group_id}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def post(
+    post_id: str = typer.Argument(..., help="Post ID"),
+    url: str | None = typer.Option(
+        None, "--url", help="Full permalink/reel URL (overrides post_id)"
+    ),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Facebook post's detail plus its top comments."""
+    data = api_get(f"/v1/facebook/posts/{post_id}", {"url": url})
+    render(data, fmt, fields)
+
+
+@app.command(name="post-comments")
+def post_comments(
+    post_id: str = typer.Argument(..., help="Post ID"),
+    url: str | None = typer.Option(
+        None, "--url", help="Full permalink/reel URL (overrides post_id)"
+    ),
+    after: str | None = AFTER,
+    sort: str = typer.Option("relevance", "--sort", help="relevance, newest, most_relevant"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Facebook post's comment thread."""
+    data = api_get(
+        f"/v1/facebook/posts/{post_id}/comments",
+        {"url": url, "after": after, "sort": sort},
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="ads-search")
+def ads_search(
+    query: str = typer.Argument(..., help="Advertiser name or keyword"),
+    country: str = typer.Option("US", "--country", "-c", help="ISO country code"),
+    ad_type: str = typer.Option("all", "--ad-type"),
+    active_status: str = typer.Option("active", "--active-status", help="active, inactive, or all"),
+    after: str | None = AFTER,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search the Facebook Ad Library."""
+    data = api_get(
+        "/v1/facebook/ads/search",
+        {
+            "query": query,
+            "country": country,
+            "ad_type": ad_type,
+            "active_status": active_status,
+            "after": after,
+        },
+    )
+    render(data, fmt, fields)

scrapebadger_cli-0.7.0/src/scrapebadger_cli/commands/instagram.py

@@ -0,0 +1,532 @@
+"""Instagram commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+AMOUNT = typer.Option(20, "--amount", "-n", help="Number of items to return")
+CURSOR = typer.Option(None, "--cursor", "-c", help="Pagination cursor")
+
+
+# ── Profile ────────────────────────────────────────────────────────────────
+
+
+@app.command()
+def user(
+    username: str = typer.Argument(..., help="Instagram username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get user profile."""
+    data = api_get(f"/v1/instagram/users/{username}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def about(
+    username: str = typer.Argument(..., help="Instagram username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get 'About this account' info."""
+    data = api_get(f"/v1/instagram/users/{username}/about")
+    render(data, fmt, fields)
+
+
+@app.command()
+def related(
+    username: str = typer.Argument(..., help="Instagram username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get related/suggested accounts."""
+    data = api_get(f"/v1/instagram/users/{username}/related")
+    render(data, fmt, fields)
+
+
+# ── Media feeds ────────────────────────────────────────────────────────────
+
+
+@app.command()
+def posts(
+    username: str = typer.Argument(..., help="Instagram username"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's posts."""
+    data = api_get(f"/v1/instagram/users/{username}/posts", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command()
+def videos(
+    username: str = typer.Argument(..., help="Instagram username"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's videos."""
+    data = api_get(f"/v1/instagram/users/{username}/videos", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command()
+def reels(
+    username: str = typer.Argument(..., help="Instagram username"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's reels."""
+    data = api_get(f"/v1/instagram/users/{username}/reels", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command()
+def tagged(
+    username: str = typer.Argument(..., help="Instagram username"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get media a user is tagged in."""
+    data = api_get(f"/v1/instagram/users/{username}/tagged", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command()
+def pinned(
+    username: str = typer.Argument(..., help="Instagram username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's pinned posts."""
+    data = api_get(f"/v1/instagram/users/{username}/pinned")
+    render(data, fmt, fields)
+
+
+# ── Media detail ───────────────────────────────────────────────────────────
+
+
+@app.command()
+def media(
+    code: str = typer.Argument(..., help="Media shortcode"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a media item by shortcode."""
+    data = api_get(f"/v1/instagram/media/{code}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def oembed(
+    code: str = typer.Argument(..., help="Media shortcode"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get oEmbed metadata for a media item."""
+    data = api_get(f"/v1/instagram/media/{code}/oembed")
+    render(data, fmt, fields)
+
+
+# ── Graph (followers / following) ──────────────────────────────────────────
+
+
+@app.command()
+def followers(
+    username: str = typer.Argument(..., help="Instagram username"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    order: str | None = typer.Option(None, "--order", help="Sort order"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's followers."""
+    data = api_get(
+        f"/v1/instagram/users/{username}/followers",
+        {"amount": amount, "cursor": cursor, "order": order},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def following(
+    username: str = typer.Argument(..., help="Instagram username"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get accounts a user follows."""
+    data = api_get(
+        f"/v1/instagram/users/{username}/following", {"amount": amount, "cursor": cursor}
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="search-followers")
+def search_followers(
+    username: str = typer.Argument(..., help="Instagram username"),
+    query: str = typer.Argument(..., help="Search query"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search within a user's followers."""
+    data = api_get(
+        f"/v1/instagram/users/{username}/followers/search",
+        {"query": query, "amount": amount, "cursor": cursor},
+    )
+    render(data, fmt, fields)
+
+
+# ── Stories & highlights ───────────────────────────────────────────────────
+
+
+@app.command()
+def stories(
+    username: str = typer.Argument(..., help="Instagram username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's active stories."""
+    data = api_get(f"/v1/instagram/users/{username}/stories")
+    render(data, fmt, fields)
+
+
+@app.command()
+def highlights(
+    username: str = typer.Argument(..., help="Instagram username"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a user's highlight reels."""
+    data = api_get(f"/v1/instagram/users/{username}/highlights")
+    render(data, fmt, fields)
+
+
+@app.command()
+def story(
+    story_pk: str = typer.Argument(..., help="Story primary key"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a single story."""
+    data = api_get(f"/v1/instagram/stories/{story_pk}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def highlight(
+    highlight_pk: str = typer.Argument(..., help="Highlight primary key"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a highlight reel and its items."""
+    data = api_get(f"/v1/instagram/highlights/{highlight_pk}")
+    render(data, fmt, fields)
+
+
+# ── Comments & likers ──────────────────────────────────────────────────────
+
+
+@app.command()
+def comments(
+    code: str = typer.Argument(..., help="Media shortcode"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get comments on a media item."""
+    data = api_get(f"/v1/instagram/media/{code}/comments", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command(name="comment-replies")
+def comment_replies(
+    code: str = typer.Argument(..., help="Media shortcode"),
+    comment_id: str = typer.Argument(..., help="Parent comment ID"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get replies to a comment."""
+    data = api_get(
+        f"/v1/instagram/media/{code}/comments/{comment_id}/replies",
+        {"amount": amount, "cursor": cursor},
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="comment-likers")
+def comment_likers(
+    code: str = typer.Argument(..., help="Media shortcode"),
+    comment_id: str = typer.Argument(..., help="Comment ID"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get users who liked a comment."""
+    data = api_get(
+        f"/v1/instagram/media/{code}/comments/{comment_id}/likers",
+        {"amount": amount, "cursor": cursor},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def likers(
+    code: str = typer.Argument(..., help="Media shortcode"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get users who liked a media item."""
+    data = api_get(f"/v1/instagram/media/{code}/likers", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+# ── Hashtags ───────────────────────────────────────────────────────────────
+
+
+@app.command()
+def hashtag(
+    tag: str = typer.Argument(..., help="Hashtag (without #)"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get hashtag metadata."""
+    data = api_get(f"/v1/instagram/hashtags/{tag}")
+    render(data, fmt, fields)
+
+
+@app.command(name="hashtag-top")
+def hashtag_top(
+    tag: str = typer.Argument(..., help="Hashtag (without #)"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get top media for a hashtag."""
+    data = api_get(f"/v1/instagram/hashtags/{tag}/top", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command(name="hashtag-recent")
+def hashtag_recent(
+    tag: str = typer.Argument(..., help="Hashtag (without #)"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get recent media for a hashtag."""
+    data = api_get(f"/v1/instagram/hashtags/{tag}/recent", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command(name="hashtag-reels")
+def hashtag_reels(
+    tag: str = typer.Argument(..., help="Hashtag (without #)"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get reels for a hashtag."""
+    data = api_get(f"/v1/instagram/hashtags/{tag}/reels", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+# ── Locations ──────────────────────────────────────────────────────────────
+
+
+@app.command()
+def location(
+    location_pk: str = typer.Argument(..., help="Location primary key"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get location metadata."""
+    data = api_get(f"/v1/instagram/locations/{location_pk}")
+    render(data, fmt, fields)
+
+
+@app.command(name="location-top")
+def location_top(
+    location_pk: str = typer.Argument(..., help="Location primary key"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get top media for a location."""
+    data = api_get(
+        f"/v1/instagram/locations/{location_pk}/top", {"amount": amount, "cursor": cursor}
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="location-recent")
+def location_recent(
+    location_pk: str = typer.Argument(..., help="Location primary key"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get recent media for a location."""
+    data = api_get(
+        f"/v1/instagram/locations/{location_pk}/recent", {"amount": amount, "cursor": cursor}
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="location-search")
+def location_search(
+    query: str | None = typer.Option(None, "--query", "-q", help="Location name"),
+    lat: float | None = typer.Option(None, "--lat", help="Latitude"),
+    lng: float | None = typer.Option(None, "--lng", help="Longitude"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search locations by name or coordinates."""
+    data = api_get("/v1/instagram/locations/search", {"query": query, "lat": lat, "lng": lng})
+    render(data, fmt, fields)
+
+
+# ── Search ─────────────────────────────────────────────────────────────────
+
+
+@app.command(name="search-users")
+def search_users(
+    query: str = typer.Argument(..., help="Search query"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search users."""
+    data = api_get("/v1/instagram/search/users", {"query": query})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-hashtags")
+def search_hashtags(
+    query: str = typer.Argument(..., help="Search query"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search hashtags."""
+    data = api_get("/v1/instagram/search/hashtags", {"query": query})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-places")
+def search_places(
+    query: str | None = typer.Option(None, "--query", "-q", help="Search query"),
+    lat: float | None = typer.Option(None, "--lat", help="Latitude"),
+    lng: float | None = typer.Option(None, "--lng", help="Longitude"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search places by name or coordinates."""
+    data = api_get("/v1/instagram/search/places", {"query": query, "lat": lat, "lng": lng})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-top")
+def search_top(
+    query: str = typer.Argument(..., help="Search query"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Top (blended) search across users, hashtags, and places."""
+    data = api_get("/v1/instagram/search/top", {"query": query})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-reels")
+def search_reels(
+    query: str = typer.Argument(..., help="Search query"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search reels."""
+    data = api_get("/v1/instagram/search/reels", {"query": query})
+    render(data, fmt, fields)
+
+
+@app.command(name="search-music")
+def search_music(
+    query: str = typer.Argument(..., help="Search query"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search music/audio."""
+    data = api_get("/v1/instagram/search/music", {"query": query})
+    render(data, fmt, fields)
+
+
+@app.command()
+def autocomplete(
+    query: str = typer.Argument(..., help="Partial search query"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get search autocomplete suggestions."""
+    data = api_get("/v1/instagram/search/autocomplete", {"query": query})
+    render(data, fmt, fields)
+
+
+# ── Audio ──────────────────────────────────────────────────────────────────
+
+
+@app.command()
+def audio(
+    audio_id: str = typer.Argument(..., help="Audio/music ID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get audio track metadata."""
+    data = api_get(f"/v1/instagram/audio/{audio_id}")
+    render(data, fmt, fields)
+
+
+@app.command(name="audio-media")
+def audio_media(
+    audio_id: str = typer.Argument(..., help="Audio/music ID"),
+    amount: int = AMOUNT,
+    cursor: str | None = CURSOR,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get media using an audio track."""
+    data = api_get(f"/v1/instagram/audio/{audio_id}/media", {"amount": amount, "cursor": cursor})
+    render(data, fmt, fields)
+
+
+@app.command(name="trending-audio")
+def trending_audio(
+    product: str | None = typer.Option(None, "--product", "-p", help="Product/surface filter"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get trending audio."""
+    data = api_get("/v1/instagram/audio/trending", {"product": product})
+    render(data, fmt, fields)

{scrapebadger_cli-0.6.0 → scrapebadger_cli-0.7.0}/src/scrapebadger_cli/commands/vinted.py

@@ -9,7 +9,7 @@ app = typer.Typer(no_args_is_help=True)
 
 FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
 FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
-MARKET = typer.Option("fr", "--market", "-m", help="Vinted market code (fr, de, uk, us, etc.)")
+MARKET = typer.Option("fr", "--market", "-m", help="Vinted market code (fr, de, gb, us, au, etc.)")
 
 
 @app.command()

{scrapebadger_cli-0.6.0 → scrapebadger_cli-0.7.0}/src/scrapebadger_cli/main.py

@@ -4,13 +4,16 @@ import typer
 
 from scrapebadger_cli.commands import (
     amazon,
+    apartments,
     auth,
     chatgpt,
     depop,
     ebay,
+    facebook,
     google,
     idealista,
     immobiliare,
+    instagram,
     leboncoin,
     linkedin,
     loopnet,
@@ -34,6 +37,7 @@ app = typer.Typer(
 
 app.add_typer(twitter.app, name="twitter", help="Twitter/X data commands")
 app.add_typer(reddit.app, name="reddit", help="Reddit data commands")
+app.add_typer(instagram.app, name="instagram", help="Instagram data commands")
 app.add_typer(stream.app, name="stream", help="Real-time streaming commands")
 app.add_typer(vinted.app, name="vinted", help="Vinted marketplace commands")
 app.add_typer(amazon.app, name="amazon", help="Amazon marketplace commands")
@@ -50,8 +54,14 @@ app.add_typer(realtor.app, name="realtor", help="Realtor real-estate commands")
 app.add_typer(loopnet.app, name="loopnet", help="LoopNet commercial real estate commands")
 app.add_typer(depop.app, name="depop", help="Depop marketplace commands")
 app.add_typer(redfin.app, name="redfin", help="Redfin real-estate commands")
+app.add_typer(apartments.app, name="apartments", help="Apartments.com rental commands")
 app.add_typer(linkedin.app, name="linkedin", help="LinkedIn public data commands")
 app.add_typer(chatgpt.app, name="chatgpt", help="ChatGPT LLM scraping commands")
+app.add_typer(
+    facebook.app,
+    name="facebook",
+    help="Facebook pages, groups, posts, search & Marketplace commands",
+)
 app.command()(auth.auth)
 app.command(name="credits")(auth.credits)
 app.command(name="logout")(auth.logout)

{scrapebadger_cli-0.6.0 → scrapebadger_cli-0.7.0}/uv.lock

@@ -228,7 +228,7 @@ wheels = [
 
 [[package]]
 name = "scrapebadger-cli"
-version = "0.4.1"
+version = "0.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },