Royal Road Scraper: 49 Data Fields, Up to 1,000 Free Results/Month

Royal Road Scraper offers four distinct modes for collecting data from Royal Road, allowing you to browse curated lists, run advanced searches with 16 genre and 72 tag filters, fetch full fiction details including chapter lists, or list all fictions by a specific author. Each record comes with up to 49 output fields, and no login or proxy is required to access the public data. Apify's free plan includes $5.00 of monthly usage, covering up to 1,000 results of this Actor. This tool is designed for developers building reader discovery tools, content aggregators, or those conducting market research on web fiction trends. It is not for anyone who needs the full chapter body text, which the records do not include.

Try it: open Royal Road Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Royal Road Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Royal Road Scraper a month, before run-start charges and platform usage.

Royal Road Scraper was last updated on 2026-07-13. It is one of 1,724 Actors CrawlerBros publishes on Apify, which together have 700,263 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Royal Road Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 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.

On Apify's free plan, each result from this Actor costs $0.005, or $5.00 per 1,000 results. The primary control influencing your bill is maxItems, as it directly limits the number of records written to your dataset. To efficiently evaluate if this Actor meets your needs, start with a small maxItems value (e.g., 25) to test various mode and filter combinations before committing to larger data extraction tasks.

How do you run Royal Road Scraper from the API?

The schema marks 1 of its 22 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Royal Road Scraper, so the request works once your token is in place.

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~royalroad-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"browse","fictionUrls":["https://www.royalroad.com/fiction/21220/mother-of-learning"],"authorUrls":["https://www.royalroad.com/profile/100374"]}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "browse",
  "fictionUrls": [
    "https://www.royalroad.com/fiction/21220/mother-of-learning"
  ],
  "authorUrls": [
    "https://www.royalroad.com/profile/100374"
  ]
}

run = client.actor("crawlerbros~royalroad-scraper").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 = {
  "mode": "browse",
  "fictionUrls": [
    "https://www.royalroad.com/fiction/21220/mother-of-learning"
  ],
  "authorUrls": [
    "https://www.royalroad.com/profile/100374"
  ]
}

const run = await client.actor('crawlerbros~royalroad-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Royal Road Scraper inputs matter, and which can you skip?

This Actor's 22 controls, with mode being the only required one, let you tailor your Royal Road data collection. The mode control is crucial; it dictates whether you are browsing lists, searching, getting specific fiction details, or pulling an author's works. For a first run, focus on setting mode and either listType (for browsing) or searchKeyword (for searching) and leave other advanced filters alone until you understand the basic output.

• mode (string): What to fetch. Default: "browse".
• fictionUrls (array): Royal Road fiction URLs (e.g. https://www.royalroad.com/fiction/21220/mother-of-learning) or bare numeric fiction IDs. Default: [].
• authorUrls (array): Royal Road author profile URLs (e.g. https://www.royalroad.com/profile/100374) or bare numeric profile IDs. Default: [].
• listType (string): Which curated Royal Road list to scrape. Default: "bestRated".
• risingStarsGenre (string): Optional. Royal Road publishes a separate Rising Stars ranking (~50 fictions) for each genre. Leave blank for the overall cross-genre Rising Stars list. Default: "".
• searchTitle (string): Match fictions whose title contains this text.
• searchKeyword (string): Free-text keyword search across title and description. Default: "dungeon".
• searchAuthor (string): Match fictions by a specific author name.
• genres (array): Only include fictions tagged with at least one of these genres. Default: [].
• tags (array): Only include fictions tagged with at least one of these secondary tags. Default: [].
• contentWarnings (array): Only include fictions flagged with at least one of these content warnings. Default: [].
• excludeTags (array): Exclude fictions tagged with any of these genres, tags, or content warnings. Default: [].

The other 10 controls, with their defaults, are listed in the input schema on Royal Road Scraper on Apify.

Fixed-choice controls: mode accepts browse (Browse a curated list), search (Advanced search), fictionDetail (Fiction detail (by URL/ID) - includes chapter list), byAuthor (Fictions by author (by URL/ID)); listType accepts 9 values (default bestRated), including bestRated (Best Rated), trending (fixed top ~50, no pagination), activePopular (Ongoing Fictions (Active Popular)), complete (Complete Fictions); risingStarsGenre accepts 17 values (default ""), including "" (All genres (overall Rising Stars)), action, adventure, comedy.

What does Royal Road Scraper return?

The records returned are comprehensive for fiction metadata, including title, description, and detailed chapter lists for individual fictions. You will also find various scores, page counts, and author information. What you will conspicuously not find is the actual body text of the chapters; the Actor provides chapter metadata like titles and URLs but does not scrape the chapter content itself.

• slug, coverUrl
• fictionType (Original / Fan Fiction), status (ONGOING / COMPLETED / HIATUS / STUB / DROPPED / INACTIVE)
• genres[], tags[], contentWarnings[]
• followers, rating (0-5), pages, views, chapterCount, lastUpdated, description
• authorName, authorId, authorUrl
• overallScore, styleScore, storyScore, grammarScore, characterScore (each 0-5)
• totalViews, averageViews, followers, favorites, ratingsCount, pages, wordCount
• language (e.g. en-US), publishedAt (original publish date), lastUpdated (last chapter date), isFree (whether the fiction is currently fully free to read)
• chapterCount, firstChapterUrl
• chapters[] - each with chapterId, title, url, order, publishedAt, isFree
• authorId, authorUrl, authorName, authorAvatarUrl attached to every fiction record
• authorJoinedAt, authorLastActive - from the author's public profile page
• authorGender, authorLocation, authorBio - only when the author has filled these in on their public profile
• authorFollowsCount, authorFavoritesCount, authorReviewsCount, authorFictionsCount - the author's own public activity counters

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 Royal Road Scraper 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. Start a run with mode set to "browse" and listType set to "bestRated" to get a baseline of well-regarded fictions.
2. Inspect the output to understand the common fields, especially genres, tags, and status, before exploring more specific queries.
3. Transition to mode "search", setting genres to a specific type like ["fantasy"] and tags to ["litrpg", "progression"] to narrow down your focus.
4. Adjust minRating and status (e.g., ["ONGOING"]) in search mode to refine the results further, checking if the number of returned items is reasonable for your needs.
5. If you need detailed chapter information for specific fictions, switch mode to "fictionDetail" and provide the fictionUrls from your previous browse or search results.
6. For author-specific content, use mode "byAuthor" with authorUrls, then cross-reference with "fictionDetail" for full fiction data.
7. For any mode, adjust the maxItems to control the number of results, starting with a small number like 50 to test your filters before scaling up.

How do you apply it? Three worked playbooks

These are Royal Road Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Reader discovery tools

Outcome: Build recommendation feeds from Royal Road's curated lists and tag taxonomy

Configure: Set mode to "browse" and listType to a curated list like "trending" or "bestRated". If focusing on a specific subgenre, set risingStarsGenre to a genre like "fantasy" with listType as "risingStars". Set maxItems to control the size of your recommendation feed.

Working method: Begin by exploring different listType options, checking the variety and relevance of fictions returned. Then, experiment with risingStarsGenre for genre-specific insights. You'll want to review the genres, tags, rating, and description fields to understand the fiction's content and audience before adding it to a feed.

Deliverable: A dataset of recommended fictions, each with core metadata, suitable for import into a reader recommendation engine or a personalized content feed.

Stop condition: Output records consistently lack descriptive tags or have irrelevant genres for the chosen list type, indicating a misalignment with the desired feed content.

Use case 2: Market research

Outcome: Track which genres/tags are trending among progression-fantasy and LitRPG readers

Configure: Set mode to "search". Use genres (e.g., ["fantasy"]) and tags (e.g., ["litrpg", "progression"]) to define your target market. Experiment with orderBy set to "popularity" or "views" and sortDirection to "desc".

Working method: Start with broad genre and tag filters, then progressively narrow them to identify niche trends. Analyze tags, rating, followers, and views for fictions in your target genres to see which elements are gaining traction. Running scheduled searches over time can reveal shifts in popular trends.

Deliverable: A structured dataset containing fiction metadata, including genres, tags, rating, and engagement metrics (followers, views), enabling analysis of trending topics and reader preferences.

Stop condition: The returned fictions consistently fall outside the expected genres or tags, or the sorting by popularity or views does not reflect current trends on Royal Road.

Use case 3: Content aggregators

Outcome: Mirror fiction metadata (title, description, chapter list, cover art) for a directory site

Configure: Set mode to "fictionDetail" and provide a list of fictionUrls or IDs. Alternatively, use "byAuthor" with authorUrls to get all fictions from specific creators, then run the resulting fiction IDs through "fictionDetail" in a second step.

Working method: Prioritize getting accurate and complete metadata for each fiction. Use fictionDetail mode to ensure you capture title, description, coverUrl, and the full chapters list. For a large catalog, consider splitting fictionUrls into smaller batches to manage run times and resource consumption.

Deliverable: A comprehensive collection of fiction records, each with title, description, coverUrl, and a nested array of chapters including their titles and URLs, ready for integration into a content directory.

Stop condition: Output records frequently show missing description fields, incomplete chapters lists, or incorrect coverUrl values, preventing the accurate mirroring of fiction metadata.

What breaks, and how do you design around it?

When hitting the fixed size of Trending or Rising Stars lists, which cap around 50 results on Royal Road, adjust your strategy to target other paginated lists like Best Rated or Complete if you need more volume. If Writathon is empty, this signals that no writing challenges are active, and you should switch to a different listType for current content. Remember that content warnings are not typically visible on Royal Road's site itself; filtering by contentWarnings will work, but don't expect the output contentWarnings field to be populated unless Royal Road explicitly shows it as a regular tag.

When should you not use Royal Road Scraper?

Avoid using this Actor if your primary requirement is to retrieve the full body text of Royal Road chapters. This Actor is explicitly designed to collect metadata such as titles, descriptions, and chapter lists, not the content of the chapters themselves. Attempting to modify this Actor to scrape chapter content would involve a significantly different and more resource-intensive approach, likely requiring a full browser and custom logic for page traversal. If you need a more generalized web scraping solution for extracting content from various web pages, consider a custom-built solution or a more generic web scraping Actor. Furthermore, if your goal is to acquire data that requires user authentication or interaction on Royal Road, this Actor will not serve your needs, as it operates exclusively on publicly accessible pages without login. Similarly, for general tech news aggregation beyond serialized fiction, you might find Lobsters Scraper or Dev.to Scraper to be more appropriate tools for their respective platforms.

What should you check before trusting the output?

• Check that fictionId and title are present and not empty for every record; missing values here indicate a fundamental issue with the record.
• Verify that the sourceUrl for each fiction is a valid Royal Road URL and resolves correctly.
• When using search filters, confirm that genres and tags in the output records align with your input criteria, looking for unexpected exclusions.
• For fictionDetail mode, ensure that the chapters array is populated with title and url for each chapter, and that chapterCount matches the array length.
• Monitor status and fictionType fields for consistency; if you filter for 'COMPLETED' fictions, ensure no 'ONGOING' records appear.
• For byAuthor mode, check that all returned fictions correctly attribute to the specified author's authorId and authorUrl.

None of this proves a record is correct. It gives a scheduled Royal Road Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What kind of data does this Actor return for fictions?

For each fiction, this Actor returns a wide array of metadata including fictionId, title, sourceUrl, coverUrl, fictionType, status, genres, tags, contentWarnings, followers, rating, pages, views, chapterCount, lastUpdated, and description. In fictionDetail mode, it also provides authorName, overallScore, totalViews, language, publishedAt, and a detailed chapters array with title, URL, and publish date for each chapter. Empty fields are always omitted from the record.

How much does it cost to use Royal Road Scraper?

The cost of using this Actor on Apify's free plan is $0.005 per result, which amounts to $5.00 per 1,000 results. Apify's free plan provides $5.00 of monthly usage without requiring a credit card, covering up to 1,000 results of this Actor before any run-start charges or additional platform usage fees. Paid Apify plans offer lower per-result rates.

Why do some lists like 'Trending' only return around 50 results?

Royal Road itself publishes certain curated lists, such as 'Trending' and 'Rising Stars', as fixed-size algorithmic rankings that cap around 50 fictions. This is a limitation of the source website, not the Actor. If you need more results, you should use other paginated lists like 'Best Rated', 'Complete', or 'Latest Updates', which this Actor can scrape fully.

Can I get chapter body text with this Actor?

No, this Actor does not return the full body text of chapters. It is designed to extract chapter metadata, including the chapter's title, URL, publish date, and whether it's free or premium. Fetching the actual content of each chapter would require a significantly different scraping approach, which is outside the scope of this Actor.

What's the difference between 'genres' and 'tags' in the input?

Royal Road's own taxonomy distinguishes between broader 'genres' (like Fantasy, Sci-fi, Romance) and more specific 'tags' (like LitRPG, Dungeon Core, Time Loop). While both function similarly for search filtering on Royal Road, this Actor separates them into distinct input controls (genres and tags) to provide a clearer and more organized user interface for constructing your queries.

Where to go next

When you are ready to run it, open Royal Road Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• Lobsters Scraper: Scrape Lobsters (lobste.rs) â€" a curated tech link aggregator.
• Dev.to Scraper: Scrape Dev.to, the popular blogging platform for developers (forem.com).

Related guides:

• Wattpad Story Scraper: Up to 1,000 Free Results a Month (2026)
• Archive of Our Own (AO3) Scraper: Up to 1,000 Free Results a Month

Resources

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

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

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

• Royal Road Scraper on Apify