
Steam Store Scraper
scrape.ly/store/shelfbright/steam-store-scraperE-commerceDeveloper tools
1 monthly user

Crawl whole websites and extract clean text and Markdown for AI models, vector databases, and RAG pipelines. Removes navigation and boilerplate and keeps titles, metadata, and links.
Turn public docs, help centers, and blogs into clean Markdown and text your RAG pipeline can index.
Built for teams who put customer-facing sites into a vector store or agent knowledge base and need a crawl that finishes, even when one URL fails.
startUrls and follow same-site links under that path, up to maxCrawlDepth, maxCrawlPages, and maxResults.includeUrlGlobs and excludeUrlGlobs. Start URLs are still fetched when an exclude glob matches them.text and, when saveMarkdown is on, markdown from the page you actually downloaded. A JSON or plain-text response is saved as text. A page whose sentences exist only after JavaScript is opened in Chrome, and the saved text is the text that page shows. Server-rendered pages stay on HTTP unless you set a browser input.removeElementsCssSelector and keepElementsCssSelector, then run htmlTransformer: readableText, readableTextIfPossible, extractus, defuddle, or none.title, description, author, keywords, languageCode, canonicalUrl, openGraph, jsonLd, and response headers (cookie and authorization headers are left out).useSitemaps) and from /llms.txt plus same-host Markdown links (useLlmsTxt).respectRobotsTxtFile).saveFiles or saveContentTypes, download linked files and store them only after the magic bytes match. PDF text and DOCX text are extracted when the file contains them. CSV is stored as text.errors dataset. The rest of the crawl continues.proxyConfiguration uses Scrapely Proxy. When proxy is on and no group is set, the run uses the residential group. A proxy country you pick is passed through.Server-rendered pages are fetched with HTTP and a Chrome TLS fingerprint. When the HTML is only a script that writes the sentences a visitor would see, that URL is loaded in Chrome and the dataset stores that rendered text. Chrome is also used when you set clickElementsCssSelector, dynamicContentWaitSecs, maxScrollHeightPixels, removeCookieWarnings, or blockMedia. Those inputs are applied on that page: matching elements are clicked, Chrome waits the number of seconds you set, the page is scrolled up to the pixel limit, cookie and consent banners are removed, and images, fonts, stylesheets, and videos are left unloaded when you ask for that. The form does not include saveScreenshots, summarize, or pageFunction. This actor does not save screenshots, write summaries, or run a page function.
maxCrawlPages and maxResults stop a runaway crawl of a large docs site.errorCode and errorExplanation.text, Markdown when you ask for it, and source metadata you can cite.ignoreCanonicalUrl when the site publishes a canonical you do not want to trust.{
"blockMedia": false,
"proxyConfiguration": {
"useScrapelyProxy": true
},
"respectRobotsTxtFile": true,
"startUrls": [
{
"url": "https://docs.python.org/3/tutorial/"
}
],
"storeSkippedUrls": false,
"useLlmsTxt": false,
"useSitemaps": false
}
One item from a real run of the example input, shortened. Long text is cut and lists show their first entries.
{
"url": "https://docs.python.org/3/tutorial/",
"crawl": {
"loadedUrl": "https://docs.python.org/3/tutorial/",
"loadedTime": "2026-10-13T19:23:30.526Z",
"depth": 0,
"httpStatusCode": 200,
"contentLengthBytes": 37315,
"contentType": "text/html"
},
"metadata": {
"canonicalUrl": "https://docs.python.org/3/tutorial/index.html",
"title": "The Python Tutorial — Python 3.15.0 documentation",
"description": "Python is an easy to learn, powerful programming language. It has efficient high-level data structures and a simple but effective approach to object-oriented…",
"languageCode": "en",
"openGraph": [
{
"property": "…",
"content": "…"
},
{
"property": "…",
"content": "…"
}
],
"headers": {
"server": "nginx",
"content-type": "text/html",
"last-modified": "Tue, 13 Oct 2026 15:50:36 GMT",
"etag": "\"6ace534c-91c3\"",
"x-clacks-overhead": "GNU Terry Pratchett",
"strict-transport-security": "max-age=315360000; includeSubDomains; preload",
"content-encoding": "gzip",
"via": "1.1 varnish, 1.1 varnish",
"accept-ranges": "bytes",
"age": "1527",
"date": "Tue, 13 Oct 2026 19:23:30 GMT",
"x-served-by": "cache-lga-kjfk8660037-LGA, cache-pdk-kpdk2140044-PDK",
"x-cache": "HIT, HIT",
"x-cache-hits": "62, 0",
"x-timer": "S1791919410.165256,VS0,VE1",
"vary": "Accept-Encoding",
"content-length": "7713"
}
},
"text": "The Python Tutorial\n\nTip\n\nThis tutorial is designed for\n\nprogrammers\nthat are new to the Python language,\n\nnot\n\nbeginners\nwho are new to programming.\n\nPython…",
"markdown": "# The Python Tutorial\n\nTip\n\nThis tutorial is designed for\n*programmers* that are new to the Python language,\n**not** *beginners* who are new to programming.\n…"
}
You pay $0.0005 per crawled page ($0.50 per 1,000 pages) plus platform usage. Only pages saved with content (text, Markdown or HTML) are charged. Skipped URLs, failed URLs (they go to the separate errors dataset) and pages without content are not charged.
Worked example: 1,000 pages ≈ $0.50 in event fees plus platform usage. On our test runs at the default 1024 MB, usage was about $0.002 for the 17-page example input and about $0.014 for 100 large documentation pages, so 1,000 pages come to roughly $0.65 in total.
Set a maximum charge for the run if you want a hard cap. The run then stops cleanly once it is reached and keeps every page saved so far.
Required: startUrls, proxyConfiguration.
| Field | What it does |
|---|---|
startUrls | Pages to crawl, or a requestsFromUrl list of URLs. |
includeUrlGlobs, excludeUrlGlobs | Extra pages to allow, or linked pages to skip. |
maxCrawlDepth, maxCrawlPages, maxResults | Depth, fetch count, and saved-item count. |
useSitemaps, useLlmsTxt, respectRobotsTxtFile | Sitemap discovery, /llms.txt, robots.txt. |
keepUrlFragments, ignoreCanonicalUrl | Keep #fragments in the URL, or save pages even when the canonical was already saved. |
proxyConfiguration | Scrapely Proxy on or off, with optional proxy groups and country, or your own proxy URLs. |
initialCookies, customHttpHeaders | Sent on requests. A custom User-Agent is not applied over the TLS profile. |
initialConcurrency, maxConcurrency | Parallel fetches, capped at 8. |
requestTimeoutSecs, maxRequestRetries, maxSessionRotations | Timeout and retry limits. |
minFileDownloadSpeedKBps | Abort a file whose average speed stays under this for more than 10 seconds. |
ignoreHttpsErrors | Continue when the TLS certificate does not verify. |
dynamicContentWaitSecs | Above 0, open the page in Chrome and wait that many seconds before saving. 0 does not open Chrome by itself. |
maxScrollHeightPixels | Above 0, open the page in Chrome and scroll down to that height. 0 does not scroll. |
removeCookieWarnings | When on, open the page in Chrome and remove short cookie, consent, or GDPR banners. |
blockMedia | When on, open the page in Chrome and do not load images, fonts, stylesheets, or videos. Scripts still load. |
clickElementsCssSelector | When set, open the page in Chrome and click matching elements that do not leave the page. |
waitForSelector | Fail that URL if the selector is missing from the fetched HTML. In Chrome, a non-zero dynamic wait also waits for this selector. softWaitForSelector does not fail the URL. |
expandIframes | Fetch up to five same-host iframes and inline them. |
keepElementsCssSelector, removeElementsCssSelector | DOM keep and remove lists. |
htmlTransformer, readableTextCharThreshold | Which cleaner runs, and when readable text is long enough to keep. |
aggressivePrune | Drop long lines that already appeared on an earlier page. |
saveMarkdown, saveHtml, saveHtmlAsFile | Markdown field, HTML field, or an HTML snapshot in the key-value store. |
saveFiles, saveContentTypes | Download linked documents or responses whose content type matches. |
debugMode, debugLog, storeSkippedUrls | Transformer lengths, verbose logs, and a SKIPPED_URLS record. |
saveScreenshots, summarize, and pageFunction are not on the form. A customer cannot request a screenshot, a summary, or a page function.
crawlerType, signHttpRequests, clientSideMinChangePercentage, renderingTypeDetectionPercentage, reuseStoredDetectionResults, and stickyContainerCssSelector are not on the form. A run that sends one of them is rejected and does not start. This actor does not sign Web Bot Auth requests and does not guess whether a page is client-rendered.
Bodies larger than 20 MB are not stored.
Each saved page is one default-dataset item. Empty fields are omitted. false and 0 are kept when they are real.
urlcrawl.loadedUrl, crawl.loadedTime, crawl.referrerUrl, crawl.depth, crawl.httpStatusCode, crawl.contentLengthBytes, crawl.contentTypemetadata.canonicalUrl, metadata.title, metadata.description, metadata.author, metadata.keywords, metadata.languageCode, metadata.openGraph, metadata.jsonLd, metadata.headerstextmarkdown when saveMarkdown produced Markdownhtml when saveHtml is onhtmlUrl when a snapshot was storeddebug when debugMode is onFailed URLs go to the errors dataset: url, attempts, httpStatus, errorCode, retryable, errorExplanation, advice, and sometimes debug.contentType. The response body is not stored there.
Downloaded files use key-value keys prefixed with file-. HTML snapshots use html-. This actor does not write screenshotUrl or summary.
Every field below can be set in the run form, passed through the API, or saved as a task. Unset fields fall back to the defaults shown.
startUrlsarrayRequiredStart URLs
Pages to start crawling from. Sub-pages are crawled too, e.g. https://example.com/blog also covers https://example.com/blog/post. Include URL patterns can widen this.
maxCrawlPagesintegerOptionaldefault 9999999Max pages
The maximum number pages to crawl. It includes the start URLs, pagination pages, pages with no content, etc. The crawler will automatically finish after reaching this number. This setting is useful to prevent accidental crawler runaway.
Which pages are crawled and stored.
includeUrlGlobsarrayOptionaldefault []Include URL patterns (globs)
Glob patterns for links to crawl beyond the start URLs and their sub-pages, e.g. https://www.example.com/blog/** matches every blog page. Only applies to links found on pages; start URLs are always crawled.
excludeUrlGlobsarrayOptionaldefault []Exclude URL patterns (globs)
Glob patterns for links to skip, e.g. https://{store,docs}.example.com/** or https://example.com/**/*?*foo=*. Start URLs are always crawled.
maxCrawlDepthintegerOptionaldefault 20Max crawling depth
How many links away from the start URLs to follow. Start URLs are depth 0; 0 crawls only the start URLs.
maxResultsintegerOptionaldefault 9999999Max results
The maximum number of web pages and files to store. This setting helps prevent an accidental crawler runaway by automatically stopping the crawl once this limit is reached. Note that the crawler skips pages whose canonical URL matches a page that has already been crawled, so it may crawl more pages than the number of stored results. Similarly, there may be more stored results than crawled web pages because downloaded files also count toward results.
keepUrlFragmentsbooleanOptionaldefault falseURL #fragments identify unique pages
Indicates that URL fragments (e.g. http://example.com#fragment) should be included when checking whether a URL has already been visited or not. Typically, URL fragments are used for page navigation only and therefore they should be ignored, as they don't identify separate pages. However, some single-page websites use URL fragments to display different pages; in such a case, this option should be enabled.
ignoreCanonicalUrlbooleanOptionaldefault falseIgnore canonical URLs
If enabled, the Actor will ignore the canonical URL or the `ETag` header reported by the page, and use the actual URL instead. You can use this feature for websites that report invalid canonical URLs, which causes the Actor to skip those pages in results.
respectRobotsTxtFilebooleanOptionaldefault falseRespect the robots.txt file
If enabled, the crawler will consult the robots.txt file for the target website before crawling each page. At the moment, the crawler does not use any specific user agent identifier. The crawl-delay directive is also not supported yet.
useSitemapsbooleanOptionaldefault falseLoad URLs from Sitemaps
Also queue matching URLs from the sitemaps of the start URL domains. You can add a sitemap.xml directly as a start URL. Finds pages that aren't linked, but large sitemaps can take a long time. Sitemap pages get depth 1.
useLlmsTxtbooleanOptionaldefault falseCrawl /llms.txt and Markdown files
If enabled, the crawler will look for `/llms.txt` files at the root of the domains of the provided Start URLs (e.g., `https://example.com/llms.txt`) and enqueue them for crawling. Note that this also enables crawling other Markdown files and enqueueing links from them.
htmlTransformerenumOptionaldefault "readableText"HTML transformer
How to extract the main content after elements are removed or clicked. Readable text (default) uses Mozilla Readability and drops headers, footers and navigation. Readable text with fallback keeps the original HTML when the page isn't clearly an article. Extractus and Defuddle are alternative extractors; Defuddle keeps math, footnotes and code better. None only does basic cleaning.
removeElementsCssSelectorstringOptionaldefault "nav, footer, script, style, noscript, svg, img[src^='data:…Remove HTML elements (CSS selector)
CSS selector for elements removed before text extraction. The default removes navigation, headers, footers, modals, scripts and inline images. Set it to a selector that matches nothing (e.g. dummy_keep_everything) to keep everything.
keepElementsCssSelectorstringOptionaldefault ""Keep HTML elements (CSS selector)
CSS selectors for the only content to keep, e.g. div, #element-id or .class-name. Everything else is removed. Runs before HTML transformer; if content goes missing, try setting HTML transformer to None.
clickElementsCssSelectorstringOptionaldefault ""Expand clickable elements
A CSS selector for elements Chrome clicks before the text is saved, so a collapsed section can open. The selector must be valid for `document.querySelectorAll()`. Links that leave the page are not clicked. An empty value does not click and does not open Chrome. A non-empty value opens the page in Chrome.
aggressivePrunebooleanOptionaldefault falseRemove duplicate text lines
This is an experimental feature. If enabled, the crawler will prune content lines that are very similar to the ones already crawled on other pages, using the Count-Min Sketch algorithm. This is useful to strip repeating content in the scraped data like menus, headers, footers, etc. In some (not very likely) cases, it might remove relevant content from some pages.
removeCookieWarningsbooleanOptionaldefault falseRemove cookie warnings
When enabled, the page is opened in Chrome and short cookie, consent, or GDPR banners are removed before the text is saved. A banner is matched by its id, class, or aria-label. When disabled, this does not open Chrome.
expandIframesbooleanOptionaldefault trueExpand iframe elements
By default, the Actor will extract content from `iframe` elements. If you want to specifically skip `iframe` processing, disable this option. Up to five same-host iframe documents are fetched and inlined.
dynamicContentWaitSecsintegerOptionaldefault 0Wait for dynamic content
How long, in seconds, Chrome waits before the text is saved. When Wait for selector is set, Chrome waits for that selector and stops early if it appears. `0` does not add this wait and does not open Chrome by itself. A value above `0` opens the page in Chrome, including a server-rendered page, so content that appears during the wait is saved.
waitForSelectorstringOptionaldefault ""Wait for selector
CSS selector to wait for before extracting content, for pages that load content dynamically. Replaces the default load detection. If it doesn't appear within Wait for dynamic content, the request fails and is retried; with a 0 wait it is checked only once. With the raw HTTP client it only checks the HTML.
softWaitForSelectorstringOptionaldefault ""Soft wait for selector
If set, the crawler will wait for the specified CSS selector to appear in the page before proceeding with the content extraction. Unlike the `waitForSelector` option, this option doesn't fail the request if the selector doesn't appear within the timeout (the request processing will continue).
maxScrollHeightPixelsintegerOptionaldefault 0Maximum scroll height
How far, in pixels, Chrome scrolls down the page before the text is saved. Scrolling stops at this distance or when the page no longer grows. `0` does not scroll and does not open Chrome by itself. A value above `0` opens the page in Chrome.
blockMediabooleanOptionaldefault falseBlock loading of images and videos
When enabled, the page is opened in Chrome and images, fonts, stylesheets, and videos are not loaded. Scripts still load. When disabled, this does not open Chrome.
saveMarkdownbooleanOptionaldefault trueSave Markdown
If enabled, the crawler converts the transformed HTML of all pages found to Markdown, and stores it under the `markdown` field in the output dataset.
saveHtmlbooleanOptionaldefault falseSave HTML to dataset (deprecated)
If enabled, the crawler stores full transformed HTML of all pages found to the output dataset under the `html` field. This option has been deprecated in favor of the `saveHtmlAsFile` option, because the dataset records have a size of approximately 10MB and it's harder to review the HTML for debugging.
saveHtmlAsFilebooleanOptionaldefault falseSave HTML to key-value store
If enabled, the crawler stores full transformed HTML of all pages found to the default key-value store and saves links to the files as `htmlUrl` field in the output dataset. Storing HTML in key-value store is preferred to storing it into the dataset with the `saveHtml` option, because there's no size limit and it's easier for debugging as you can easily view the HTML.
saveFilesbooleanOptionaldefault falseSave files
Deprecated in favor of the `saveContentTypes` option. Will be removed soon. If enabled, the crawler downloads files linked from the web pages, as long as their URL has one of the following file extensions: PDF, DOC, DOCX, XLS, XLSX, and CSV. Note that unlike web pages, the files are downloaded regardless if they are under Start URLs or not. The files are stored to the default key-value store, and metadata about them to the output dataset, similarly as for web pages.
saveContentTypesstringOptionalSave linked files with Content-Type
Download files linked from pages when their Content-Type matches, using the predefined groups or custom values with wildcards (e.g. application/pdf, text/*, image/*). Files are downloaded even outside the start URLs, saved to the key-value store and listed in the dataset.
maxConcurrencyintegerOptionaldefault 200Max concurrency
The maximum number of web browsers or HTTP clients running in parallel. This setting is useful to avoid overloading the target websites and to avoid getting blocked.
initialConcurrencyintegerOptionaldefault 0Initial concurrency
The initial number of web browsers or HTTP clients running in parallel. The system scales the concurrency up and down based on the current CPU and memory load. If the value is set to 0 (default), the Actor uses the default setting for the specific crawler type. Note that if you set this value too high, the Actor will run out of memory and crash. If too low, it will be slow at start before it scales the concurrency up.
requestTimeoutSecsintegerOptionaldefault 60Page request timeout
Timeout in seconds for making the request and processing its response. Defaults to 60s.
minFileDownloadSpeedKBpsintegerOptionaldefault 128Minimum file download speed
The minimum viable file download speed in kilobytes per seconds. If the file download speed is lower than this value for a prolonged duration, the crawler will consider the file download as failing, abort it, and retry it again (up to "Maximum number of retries" times). This is useful to avoid your crawls being stuck on slow file downloads.
maxRequestRetriesintegerOptionaldefault 3Maximum number of retries on network / server errors
The maximum number of times the crawler will retry the request on network, proxy or server errors. If the (n+1)-th request still fails, the crawler will mark this request as failed.
maxSessionRotationsintegerOptionaldefault 10Maximum number of session rotations
The maximum number of times the crawler will rotate the session (IP address + browser configuration) on anti-scraping measures like CAPTCHAs. If the crawler rotates the session more than this number and the page is still blocked, it will finish with an error.
ignoreHttpsErrorsbooleanOptionaldefault falseIgnore HTTPS errors
If enabled, the scraper will ignore HTTPS certificate errors. Use at your own risk.
customHttpHeadersobjectOptionaldefault {}Custom HTTP headers
HTTP headers that will be added to all requests made by the crawler. This is useful for setting custom authentication headers or other headers required by the target website. The value is expected to be a JSON object with `name` and `value` properties pairs. For example: `{ "name1": "value1", "Authorization": "Basic a1b2c3d4..." }`.
debugModebooleanOptionaldefault falseDebug mode (stores output of all HTML transformers)
If enabled, the Actor will store the output of all types of HTML transformers, including the ones that are not used by default, and it will also store the HTML to Key-value Store with a link. All this data is stored under the `debug` field in the resulting Dataset.
debugLogbooleanOptionaldefault falseDebug log
If enabled, the actor log will include debug messages. Beware that this can be quite verbose.
proxyConfigurationobjectRequireddefault {"useScrapelyProxy":true}Proxy configuration
Enables loading the websites from IP addresses in specific geographies and to circumvent blocking.
readableTextCharThresholdintegerOptionaldefault 100Readable text extractor character threshold
A configuration options for the "Readable text" HTML transformer. It contains the minimum number of characters an article must have in order to be considered relevant.
storeSkippedUrlsbooleanOptionaldefault falseStore skipped URLs
If enabled, the crawler will store all URLs that were skipped during the crawl in a Key-Value Store record named `SKIPPED_URLS`. The record will contain a JSON object with reasons for skipping and the URLs that were skipped for each reason. This is useful for debugging and understanding why certain pages were not crawled.
Every run writes its results to a dataset. Preview it in the dashboard, then export it or read it through the API.
No output schema
The developer has not described this actor's dataset fields. Run it once to see what it returns.
You pay for the events the actor reports, such as each result or page it produces. Platform usage is included in the event prices.
| Event | Charged when | Price |
|---|---|---|
| Crawled page | One crawled page saved to the dataset with its content (text, Markdown or HTML). | $0.0005 |
Run this actor from your own code. Swap in your API token and the examples work as-is.
import { ScrapelyClient } from 'scrapely-client'
const client = new ScrapelyClient({ token: process.env.SCRAPELY_TOKEN })
// Start the actor and wait for the run to finish.
const run = await client.actor('querystone/website-content-crawler').call({
"startUrls": [
{
"url": "https://docs.python.org/3/tutorial/"
}
],
"includeUrlGlobs": [],
"excludeUrlGlobs": [],
"respectRobotsTxtFile": true,
"useSitemaps": false,
"useLlmsTxt": false,
"removeElementsCssSelector": "nav, footer, script, style, noscript, svg, img[src^='data:'],\n[role=\"alert\"],\n[role=\"banner\"],\n[role=\"dialog\"],\n[role=\"alertdialog\"],\n[role=\"region\"][aria-label*=\"skip\" i],\n[aria-modal=\"true\"]",
"keepElementsCssSelector": "",
"clickElementsCssSelector": "",
"blockMedia": false,
"customHttpHeaders": {},
"proxyConfiguration": {
"useScrapelyProxy": true
},
"storeSkippedUrls": false
})
// Read the dataset the run produced.
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)Tokens live in your account settings. Keep them server-side: a token carries the full permissions of your account.
Connect the Scrape.ly MCP server once and your agent can run this actor as a tool. Pick your tool:
Fetch scrape.ly/agents.md and run querystone/website-content-crawlerPaste into Claude Code, Codex, Cursor or any AI agent. It signs you in once in the browser.
{
"mcpServers": {
"scrapely": {
"url": "https://api.scrape.ly/mcp?tools=actors,runs,storage,docs&actors=querystone/website-content-crawler"
}
}
}No key in the file: your client opens the browser to sign you in the first time it connects.
Inputs the developer prepared for common jobs. Open one to see its input, then copy it to your account to run it as-is or adjust it.
Clean readable text from a documentation crawl.
Only pages under one URL path, with saved HTML.
Pages found from the sitemap as clean text.
Scrape.ly gives you the infrastructure, the tooling, and the team to extract, process, and operationalize web data at any scale. Setup takes minutes. The advantage lasts forever.