Skip to content
    ↑↓ to choose · Enter to open

    · 12 min read

    Website Links Graph Generator: Up to 2,500 Free Results a Month (2026)

    By CrawlerBros Engineering Team

    Each record carries 7 output fields, including the page title, depth from the start URL, and lists of internal and external links. You can get up to 2,500 results a month on Apify's free plan, for $2.00 per 1,000 results. This Actor creates an oriented graph visualizing links between webpages, outputting a visual network diagram as graph.png and structured data as graph.json. It is designed for SEO specialists mapping site architecture and developers auditing internal connectivity. It is not for users who need to check the HTTP status of every link, as the records do not include server response codes.

    Try it: open Website Links Graph Generator on Apify, sign in on the free plan and run the prefilled example.

    Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.002 per result, that covers up to 2,500 results of Website Links Graph Generator a month, before run-start charges and platform usage.

    The example request further down caps maxDepth at 1, so a first run returns at most 1 results and costs at most $0.002 in result charges. That is enough to see the real shape of the data before deciding anything.

    Website Links Graph Generator was last updated on 2026-07-06. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 674,790 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

    Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.05 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

    Apify plan Per result Per 1,000 results
    FREE $0.002 $2.00
    BRONZE $0.00167 $1.67
    SILVER $0.00133 $1.33
    GOLD $0.001 $1.00
    PLATINUM $0.001 $1.00
    DIAMOND $0.001 $1.00

    The maxPages parameter is the primary driver of your bill because it directly limits the number of items written to the dataset. To test your boundaryRegex and graphLayout without incurring high costs, perform a first run with maxPages set to 3. This ensures the run returns at most 1 result for $0.002 in result charges if you use the example maxDepth of 1.

    The schema marks 1 of its 10 controls as required: startUrl. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

    Call the synchronous endpoint to start a run and receive dataset items in one request:

    curl -X POST "https://api.apify.com/v2/acts/crawlerbros~web-link-graph-visualizer/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrl":"https://example.com","maxDepth":1,"maxPages":3,"exportFormat":"json","requestDelay":500}'

    The same run from Python, using the official client:

    from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "startUrl": "https://example.com",
  "maxDepth": 1,
  "maxPages": 3,
  "exportFormat": "json",
  "requestDelay": 500
}

run = client.actor("crawlerbros~web-link-graph-visualizer").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

    And from Node.js:

    import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "startUrl": "https://example.com",
  "maxDepth": 1,
  "maxPages": 3,
  "exportFormat": "json",
  "requestDelay": 500
}

const run = await client.actor('crawlerbros~web-link-graph-visualizer').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

    That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

    Which Website Links Graph Generator inputs matter, and which can you skip?

    The startUrl is the only required control and serves as the root for the link crawl. Use boundaryRegex to define which URLs the spider is allowed to follow, and set maxDepth to prevent the crawl from expanding infinitely across complex domains.

    • startUrl (string): The URL to start crawling from
    • boundaryRegex (string): Regular expression to limit which URLs to crawl. Only URLs matching this pattern will be followed. Default: ".*".
    • maxDepth (integer): Maximum crawl depth from the start URL Default: 3.
    • maxPages (integer): Maximum number of pages to crawl Default: 50.
    • exportFormat (string): Output format for the graph Default: "both".
    • graphLayout (string): Layout algorithm for graph visualization Default: "hierarchical".
    • nodeLabels (string): What to show as node labels Default: "path".
    • includeExternal (boolean): Show external links in the graph (won't be crawled, just displayed) Default: true.
    • waitForSelector (string): Optional CSS selector to wait for before extracting links (for JavaScript-heavy sites)
    • requestDelay (integer): Delay between requests in milliseconds (be nice to servers) Default: 1000.

    Fixed-choice controls: exportFormat accepts both (Image + JSON), image (Image Only (PNG)), json (JSON Only); graphLayout accepts hierarchical (top-down), spring (force-directed), circular, random; nodeLabels accepts url (Full URL), path (URL Path), title (Page Title), index (Node Index).

    This Actor generates a graph.png and graph.json file, showing relationships between pages and their depth. Note that records do not contain the actual HTML content of the pages or any metadata beyond titles and links.

    • url - Page URL
    • title - Page title
    • depth - Depth from start URL
    • links - All extracted links
    • internal_links - Links matching boundary
    • external_links - Links outside boundary
    • crawled_at - Timestamp

    These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

    How do you build the workflow end to end?

    Open Website Links Graph Generator and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

    1. Identify your crawl's entry point and set it in the startUrl field.
    2. Define your crawl's scope by using boundaryRegex to ensure the crawler only follows specific paths, such as '^https://example\.com/.*'.
    3. Set the maxDepth and maxPages limits to control how far and wide the link spider travels.
    4. Choose either 'hierarchical' or 'spring' in the graphLayout control to determine the visual organization of your map.
    5. Toggle includeExternal to true if you need to visualize external dependencies alongside internal nodes.
    6. Provide a CSS selector in the waitForSelector field if the page requires specific elements to load before links become visible.
    7. Execute the run, then retrieve the graph.png or graph.json files from the Key-Value Store tab.

    How do you apply it? Three worked playbooks

    These are Website Links Graph Generator's own documented use cases, each worked through as an operating pattern rather than a description.

    Use case 1: Visualize site structure

    Outcome: Visualize site structure

    Configure: Set startUrl to 'https://example.com', boundaryRegex to '^https://example\.com/.*', maxDepth to 3, maxPages to 50, exportFormat to 'both', and graphLayout to 'hierarchical'.

    Working method: Execute a crawl from the homepage and allow the spider to branch out to three levels. Open the resulting graph.png to see the top-down navigation hierarchy and verify the depth of key landing pages in the Dataset.

    Deliverable: A visual PNG diagram and a structured JSON dataset mapping all internal page relationships.

    Stop condition: The hierarchical layout produces overlapping labels, indicating too many nodes for the current nodeLabels setting.

    Use case 2: Find orphan pages

    Outcome: Find orphan pages

    Configure: Set startUrl to 'https://example.com', boundaryRegex to '^https://example\.com/.*', maxDepth to 5, maxPages to 500, exportFormat to 'json', and includeExternal to false.

    Working method: Run the crawler across the entire site directory to generate a full graph.json. Analyze the 'edges' array to identify internal page nodes that have no incoming links from other internal pages within the graph.

    Deliverable: A graph.json file containing a complete network map of internal nodes and their connectivity status.

    Stop condition: The maxPages limit is reached before the crawler can discover the full site structure.

    Use case 3: Identify link depth issues

    Outcome: Identify link depth issues

    Configure: Set startUrl to 'https://example.com', boundaryRegex to '^https://example\.com/.*', maxDepth to 8, maxPages to 200, exportFormat to 'both', and nodeLabels to 'path'.

    Working method: Crawl the site with a high maxDepth to find pages buried deep in the architecture. Filter the Dataset for records where the 'depth' field is 5 or higher and trace the path of edges in graph.json to see the link chain.

    Deliverable: A Dataset of page records flagged by depth and a visual diagram showing the distance of nodes from the startUrl.

    Stop condition: The statistics object shows 'max_depth_reached' is equal to your maxDepth input, suggesting deeper pages may exist.

    What breaks, and how do you design around it?

    • Max Pages: 1000 (configurable limit)
    • Max Depth: 10 (configurable limit)
    • JavaScript: Rendered via Playwright (may be slow)
    • Image Size: Large graphs (100+ nodes) may have small labels

    Crawl depth is capped at 10 and total pages are limited to 1000 per run. When visualizing more than 100 nodes, change nodeLabels to 'index' to ensure the graph.png remains legible. Large JavaScript-heavy sites may require increasing the requestDelay to ensure the browser has time to render.

    Do not use this Actor if your primary requirement is a report on dead links or server errors. While it extracts link paths, it does not record status codes like 404 or 500 for the pages it crawls. For auditing link health, you should use Find Broken Links instead. If you need a simple visual capture of a page without structural data, Website Screenshot Generator is the better choice. If you are trying to generate synthetic user data for testing rather than mapping an existing site, use Random User Generator Scraper.

    What should you check before trusting the output?

    • Check that every Dataset record contains a non-null title and depth field.
    • Verify that the statistics object in graph.json reports internal_links and external_links counts.
    • Ensure that nodes in graph.json have is_internal booleans that align with your boundaryRegex configuration.
    • Confirm graph.png exists in the Key-Value Store if exportFormat was set to 'both' or 'image'.
    • Validate that max_depth_reached in the statistics does not exceed your maxDepth input.

    None of this proves a record is correct. It gives a scheduled Website Links Graph Generator run defined points where it should stop instead of quietly passing bad data downstream.

    Frequently asked questions

    What is the cost for a typical site crawl?

    At the free-plan price of $2.00 per 1,000 results, a 500-page site crawl costs $1.00 in result charges. Every run also incurs a $0.05 per GB run-start fee and platform usage charges based on your plan.

    Can I visualize how many external sites my pages link to?

    Yes. By setting 'includeExternal' to true, the graph will display external links as red nodes. The graph.json file also includes external_links and avg_outgoing_links in its statistics object.

    How do I ensure the crawler stays on my subdomain?

    Use the boundaryRegex input. For example, setting it to '^https://blog\.example\.com/.*' will prevent the crawler from following links that point to the main domain or other subdomains.

    Does this Actor handle sites that use JavaScript?

    This Actor uses Playwright. The 'waitForSelector' control allows you to specify a CSS selector for the Actor to wait for before extracting links, useful for JavaScript-heavy sites.

    How can I download the visual network diagram?

    Once the run completes, go to the Storage section and select the Key-Value Store tab. You can download the 'graph.png' file directly from there to view your oriented link graph.

    Where to go next

    When you are ready to run it, open Website Links Graph Generator on Apify; the free plan covers up to 2,500 results a month.

    Start with the Website Links Graph Generator Actor page for the current input schema, pricing tier, and run history.

    Other Actors we maintain for related data:

    Related guides:

    Resources

    • Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-25.

    • Actor last updated by its maintainers on 2026-07-06.

    • Run outcome figures cover the 30 day public window ending 2026-09-25.

    • Website Links Graph Generator on Apify

    Featured actors

    Website Links Graph Generator

    Creates an oriented graph visualizing links between webpages. Outputs: graph.png (visual network diagram) and graph.json (structured data) saved to Key-Value Store, plus detailed dataset of all crawled pages. Configure depth, boundaries, and layout.

    Run on Apify ↗