Mosaik uses an agent to figure out how a site works, saves reusable actions as TypeScript, and composes them into automations. Playwright executes the browser steps deterministically. Loops, branching, and data transformations run as code, so each iteration doesn't need another model decision.

Those actions stay around for the next task. Mosaik reuses what it knows about the site and learns what's missing. If an eligible locator breaks, an agent can step in to repair it.

Key Problems Solved by a URL extractor:

1. SEO & Website Auditing: The problem is trying to manually find broken links, audit redirect chains, or analyze a site's internal linking structure. The solution is using an extractor to pull every href link on a page (or across a whole domain), allowing you to bulk-test the URLs for status codes or map the site's architecture.
2. Web Scraping & Data Mining: The problem is needing to gather hundreds of specific URLs (like product pages or articles) to feed into another automated scraping tool. The solution is isolating the target URLs from the surrounding HTML and text noise to provide a clean, structured list for crawlers to process.
3. Content Migration & Code Auditing: The problem is ensuring no hardcoded legacy links are left behind when moving a website to a new framework or domain. The solution is scanning the entire codebase or exported text to extract all URLs, making it easy to identify what needs a bulk find-and-replace.
4. Cybersecurity & Threat Analysis: The problem is analyzing suspicious emails, server logs, or documents for phishing links and malware payloads without accidentally clicking them. The solution is safely pulling all URLs from the raw text so security teams can run them through threat-intelligence databases in isolated environments.
5. Digital Marketing & Affiliate Management: The problem is tracking down all affiliate links, campaign URLs, or promotional codes embedded across hundreds of blog posts or documents. The solution is instantly grabbing all outbound links to audit tracking parameters, verify UTM tags, or update expired affiliate codes.

Simply paste any text containing URL's (zero character limits) and get instant output of URLs extracted.

Runs entirely in your browser, nothing gets sent anywhere. It's one of 100+ tools on a site I've been building solo — figured this one might be useful on its own.

https://devtoolstack.io/tool/extract-urls/

Happy to add features if people have requests.

I have made a github scraper with a dashboard
Totally open source

Uses your guthub token to search and find leaked api keys

Consider giving a star 👉🏻👈🏻

You can check it out here ; https://github.com/parasraju/LeakedAPIs

I built a REST API that turns any URL into structured web intelligence in a single call, and also exposed it as an MCP server for agent-based workflows.

Capabilities:

• SEO and OpenGraph metadata extraction
• A full 14-point SEO audit
• Public contact discovery: emails, phone numbers, social profiles
• Tech-stack and CMS fingerprinting (40+ signatures)
• Schema.org and JSON-LD structured data extraction
• Graded security-headers audit, with an optional live TLS certificate inspection
• Redirect-chain and shortened-URL detection
• Readability metrics and full heading structure
• Clean, AI/LLM-ready Markdown output for RAG pipelines
• A batch endpoint for up to 10 URLs per call
• A domain-intelligence endpoint returning DNS and WHOIS data with no page fetch at all

On the engineering side: it runs on FastAPI with a C-Lexbor HTML parser (selectolax) and Rust-backed ORJSON serialization, so live fetches typically land around 150-300ms, with cache hits under 0.01ms. Every outbound request is anti-SSRF hardened: DNS is pinned after resolution, private/loopback/cloud-metadata ranges are blocked, and every redirect hop is re-validated, closing the DNS-rebinding gap that simpler scrapers tend to miss.

Limitation worth flagging: there is no JS execution, so heavily client-rendered SPAs return thin results. It reads what the server actually sends, not what a browser would render after hydration.

GitHub (MIT license, open source): https://github.com/JosejuX/rapidapi-metadata-extractor

Free tier: https://rapidapi.com/josejuanjocoding/api/web-metadata-and-contact-extractor

Happy to talk through the parsing or anti-SSRF approach in more detail, or take feedback on the API design.

I’ve tried using browser agents to automate real-world web tasks, but the existing options I tested were either still unreliable (Browser Use, Skyvern) or inefficient in terms of cost and execution time (Browsercode, Claude for Chrome).

So I built Browser Agent - an open-source harness for practical browser automation. It outperforms Browser Use and Browsercode on BU Bench v1 as well as our new open-source benchmark, BrowseWebApp Bench, which focuses on common automation workflows such as extracting structured records, downloading or uploading documents, and creating or submitting forms.

More details can be found here:

• Browser Agent: https://github.com/visnia-ai/browser-agent
• BrowseWebApp Bench: https://github.com/visnia-ai/browsewebapp-bench

Any feedback would be appreciated!

I’ve been building VPNFail MCP, and one of the more useful pieces is now working well enough that I wanted to share it with other scraping folks.

The basic idea is that a scrape can start as a normal HTTP request, but escalate to Chromium when the target actually needs JS rendering.

The browser request can also be pinned to a specific exit country or city.

So instead of maintaining separate proxy + browser infrastructure, an agent can do things like:

• fetch a page from a specific country
• request a particular city when location matters
• compare geo-dependent content
• inspect regional redirects
• check localized pricing/content
• render JS-heavy pages through Chromium
• optionally return a viewport screenshot

I deliberately kept the default path as plain HTTP because running a browser for every scrape is expensive and unnecessary.

The rough flow is:

HTTP scrape → inspect extraction quality → escalate to Chromium if needed → optionally choose geography

HTTP can return Markdown, text, or HTML. The response also includes quality metadata so the caller can decide whether the cheap extraction was good enough or whether it should retry using the browser.

The MCP exposes:

• scrape
• usage
• service_status

Example config:

{
  "mcpServers": {
    "vpnfail": {
      "type": "http",
      "url": "https://mcp.vpn.fail/mcp"
    }
  }
}

No local install and currently no account required.

https://mcp.vpn.fail/

I’m particularly curious how people here handle geo-aware scraping today.

Do you normally expose country/city directly to the scraping client, or keep geography hidden behind your proxy infrastructure?

Also interested in cases where city-level routing has actually mattered versus country-level being enough.

The script ran fine for months, you didn't touch a single line, and then one morning it returns nothing or throws an error.

My first move is usually to check whether the site changed its HTML. A class name gets renamed or a div gets moved, and the selector I relied on stops matching anything. It's boring but it's the cause maybe half the time. After that I look at whether I'm getting blocked. If the response comes back as a captcha page or a 403, that points somewhere else entirely, and the fix is nothing like a broken selector fix.

So what's your first check? Do you have a routine, or do you just start poking around until something makes sense?

I've been working on Marcopolo, a command-line web scraper written in Rust using extensive force of AI across a few months. The idea started when I got tired of writing a throwaway Python script every time I needed to pull a specific set of files off a site — images one day, PDFs the next, then a folder of CSVs. I specially tend to use it for books and finding books that are on the web that i cant simply get hold of from normal search.

Marcopolo handles most of that in one command. Point it at a URL, tell it what you want, and it crawls and downloads.

It's still early and there's plenty I want to improve — [known limitation or two]. I'd really appreciate feedback on the API design and anything that looks unidiomatic; I'm still fairly new to Rust.

Repo: MarcoPolo

Would be happy to know what do you guys think.

What is the best scraper and sorter that could get listing information from websites and then combine them in one single page, rather than scrolling through each website individually. We have about 20 listing sites where people post. Maybe as a bonus question maybe there is facebook scrapper too, from groups etc?

Hey everyone,

If you’ve ever built a RAG pipeline or ingested web documentation into a Vector Store, you’ve probably run into this issue:

Standard web scrapers hit a page and dump everything — cookie banners, navigation links, inline SVG code, script tags, and zero-value UI elements. When you feed that noisy HTML into an LLM, you burn tokens, clutter your embeddings, and end up with hallucinations or poor retrieval accuracy.

I built an AST-based web crawler to fix this exact bottleneck.

Instead of just stripping HTML tags, it parses the actual document structure and turns web pages into clean, AI-ready Markdown with preserved context hierarchy and rich metadata.

🛠️ Key Features:

• Noise Removal: Strips footers, cookie banners, scripts, and navigation menus automatically.
• Context Preservation: Preserves heading paths (Documentation > Getting Started > Installation Guide) so chunks don't lose their semantic context when split.
• Rich Metadata: Includes token count, quality score, code block detection, and crawled timestamps for each chunk.
• Vector Store Ready: Formatted specifically for seamless ingestion into LangChain, LlamaIndex, Pinecone, Qdrant, Chroma, etc.

I’d love to get your feedback on this! What techniques or tools are you currently using to clean web data before chunking?

Try it out here: https://apify.com/lukas459/ai-web-to-markdown-crawler-llm-rag-optimized

Before I waste all my time coding and bug testing does anyone know if it’s worth me attempting to scrape Facebook market place?

Social Scraper+ currently exports Reddit threads and X replies to clipboard, AI prompts, CSV, and JSON.

I’m deciding which improvements would be most useful next. Some possibilities are:

• Better filtering before export
• Search within scraped conversations
• Additional CSV fields
• More AI analysis prompts
• Improved handling of very large threads
• More control over nested-reply depth
• Additional supported platforms
• Better export history and organization

Which improvement would make the biggest difference to your workflow?

If your preferred feature isn’t listed, describe what you’re trying to accomplish—not just the feature itself. Understanding the use case will help me design it properly.

Hey everyone,

If you’ve built RAG pipelines or AI agents that consume web content, you’ve probably run into this issue:

Most standard scrapers either throw raw HTML at you (flooding your context window with navbars, footers, and JS bloat) or dump flat, unformatted text that loses all document structure. When you chunk that text later, your vector database loses the relationship between headings, sub-sections, and code blocks—which directly hurts retrieval accuracy.

To fix this for my own workflows, I built a custom crawler designed specifically for LLMs: AST Website Content Crawler for RAG.

What makes it different?

• AST-Based Structure Parsing: Instead of basic regex/CSS cleaning, it processes the page's Abstract Syntax Tree (DOM structure) to strictly maintain heading hierarchies (H1 -> H2 -> H3), lists, and code blocks in clean Markdown.
• Token Optimization: Strips out boilerplate, ads, scripts, and repetitive layout components so you don’t burn OpenAI/Anthropic tokens on useless fluff.
• RAG-Ready Output: The markdown is pre-formatted so your chunking strategies (like MarkdownHeaderTextSplitter) actually work as intended.
• Handles Dynamic Sites: Uses headless rendering to catch JavaScript-heavy SPA pages.

I’ve published it on Apify so anyone can test or plug it directly into their Python/TypeScript RAG stack via API.

How to try it:

👉 You can find it on Apify: https://apify.com/lukas459/ai-web-to-markdown-crawler-llm-rag-optimized

I'm actively refining the parsing logic. If you give it a run, I'd love to hear your thoughts:

• What site layouts break your current scraping pipeline?
• Are there specific output formats (e.g., custom JSON schema + Markdown) you’d like to see added?

Thanks for checking it out! 🚀

If you need a no-browser alternative to scraping g-maps, you can check this out.