{"id":988,"date":"2026-07-02T06:34:09","date_gmt":"2026-07-01T23:34:09","guid":{"rendered":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/02\/the-ultimate-guide-to-web-scraping-with-scrapy-from-installation-to-advanced-techniques\/"},"modified":"2026-07-02T06:34:09","modified_gmt":"2026-07-01T23:34:09","slug":"the-ultimate-guide-to-web-scraping-with-scrapy-from-installation-to-advanced-techniques","status":"publish","type":"post","link":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/02\/the-ultimate-guide-to-web-scraping-with-scrapy-from-installation-to-advanced-techniques\/","title":{"rendered":"The Ultimate Guide to Web Scraping with Scrapy: From Installation to Advanced Techniques"},"content":{"rendered":"<h1>The Ultimate Guide to Web Scraping with Scrapy: From Installation to Advanced Techniques<\/h1>\n<p>Web scraping has become an indispensable tool for data-driven decision-making in modern business, research, and development. Whether you are monitoring competitor prices, aggregating news articles, building a dataset for machine learning, or simply automating the collection of online information, the need for a robust, efficient, and scalable scraping framework is paramount. Among the myriad of scraping libraries available in the Python ecosystem, Scrapy stands out as a mature, high-level framework that does much more than just fetch web pages. It provides a complete pipeline for crawling websites at scale, handling requests asynchronously, extracting structured data, and storing it in various formats. Unlike simple libraries like Requests and BeautifulSoup, which require you to manually manage concurrency, retries, and middleware, Scrapy builds all of these features directly into its architecture, allowing you to focus on what matters most: writing the extraction logic.<\/p>\n<p>In this comprehensive guide, we will walk you through every essential aspect of using Scrapy for web scraping. We will start from the absolute basics\u2014installing Scrapy and setting up your first project\u2014and then progress through the core components of the framework: spiders, items, selectors, and pipelines. You will learn how to navigate websites, extract data using CSS and XPath selectors, and store your results in JSON, CSV, or even a database. We will also cover advanced topics such as handling dynamically loaded content with Splash, integrating custom middlewares for proxy rotation and user-agent rotation, and optimizing performance through concurrency settings. By the end of this tutorial, you will not only be able to scrape static websites with ease but also tackle modern JavaScript-heavy single-page applications. To ensure you avoid common pitfalls, we have included a detailed FAQ section and a set of best practices that emphasize ethics, legality, and efficiency. Whether you are a data analyst, a developer, or a hobbyist, this guide will transform you into a confident Scrapy user capable of building production-grade scrapers.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/via.placeholder.com\/800x600\/4a90d9\/ffffff?text=how%20to%20use%20Scrapy%20for%20web%20scraping\" alt=\"Article illustration\" style=\"display:block;margin:20px auto;max-width:100%;height:auto;border-radius:8px;\" \/><\/p>\n<h2>Step 1: Installing Scrapy and Creating Your First Project<\/h2>\n<h3>Installation via pip<\/h3>\n<p>Before you can harness the power of Scrapy, you need to install it on your system. Scrapy is a pure Python library, but it relies on several compiled dependencies for performance, particularly Twisted (an asynchronous networking engine) and lxml (a fast XML\/HTML parser). The easiest way to get everything set up is through pip. Open your terminal or command line and run the following command: <code>pip install scrapy<\/code>. On macOS or Linux, you may need to use <code>pip3<\/code> if your default Python is version 2.x. On Windows, ensure you have Python and pip correctly added to your PATH; if you encounter build errors related to Microsoft Visual C++ Build Tools, you can download them from the official Microsoft website or use Anaconda distribution, which includes precompiled binaries. Once the installation finishes, verify that Scrapy is properly installed by running <code>scrapy version<\/code> in your terminal. You should see a version number like <code>2.11.0<\/code>.<\/p>\n<h3>Creating a Scrapy Project<\/h3>\n<p>Scrapy organizes all components of a scraping job into a well-defined project structure. To create a new project, navigate to the directory where you want your code to reside and run: <code>scrapy startproject myscraper<\/code>, replacing &#8220;myscraper&#8221; with your desired project name. This command generates a folder with the following layout: a <code>scrapy.cfg<\/code> configuration file at the top level, and a subfolder named after your project (e.g., <code>myscraper\/<\/code>) containing <code>items.py<\/code>, <code>middlewares.py<\/code>, <code>pipelines.py<\/code>, <code>settings.py<\/code>, and a <code>spiders<\/code> directory. Understanding this structure is crucial because each file plays a specific role in the scraping pipeline. For example, <code>items.py<\/code> defines the data structures you will collect, <code>pipelines.py<\/code> processes and stores the scraped data, and <code>settings.py<\/code> configures global behaviors like download delays, user agents, and concurrency limits. The <code>spiders<\/code> folder is where you will write your custom spider classes that contain the actual scraping logic.<\/p>\n<h2>Step 2: Understanding the Core Components of Scrapy<\/h2>\n<h3>Architecture Overview<\/h3>\n<p>Scrapy follows a modular, event-driven architecture built on top of the Twisted asynchronous networking library. The main components you will interact with are <strong>Spiders<\/strong>, <strong>Items<\/strong>, <strong>Item Loaders<\/strong>, <strong>Selectors<\/strong>, <strong>Pipelines<\/strong>, and <strong>Middlewares<\/strong>. Spiders are the heart of any Scrapy project; they define how a website should be crawled and how data should be extracted from its pages. Items are simple Python dictionaries or custom objects that represent the data you want to collect, such as a product&#8217;s name, price, and URL. Selectors are Scrapy&#8217;s built-in tools for navigating HTML and XML documents using CSS or XPath expressions. Item Loaders provide a convenient way to populate items with data from selectors while applying input and output processors for cleaning and validation. Pipelines are used to post-process scraped items\u2014for example, checking for duplicates, sanitizing values, or storing them in a database. Middlewares sit between the engine and the downloader or between the engine and the spider, allowing you to customize request\/response processing (e.g., rotating proxies, adding cookies, or modifying headers).<\/p>\n<h3>Selectors in Depth: CSS and XPath<\/h3>\n<p>Selectors are arguably the most important part of a spider. Scrapy offers two syntaxes: CSS selectors and XPath expressions. CSS selectors are familiar to web developers and are often more readable for basic tasks. For example, <code>response.css('div.product')<\/code> selects all <code>div<\/code> elements with class <code>product<\/code>. XPath, on the other hand, is more powerful and can navigate up and down the DOM tree, filter by text content, and perform complex conditions. For instance, <code>response.xpath('\/\/div[@class=\"product\"]\/h2\/text()')<\/code> extracts the text inside every <code>h2<\/code> that is a direct child of a <code>div<\/code> with class <code>product<\/code>. In practice, you will often combine both. Scrapy&#8217;s selector API also includes convenience methods like <code>.get()<\/code> (returns first result) and <code>.getall()<\/code> (returns list). To help you become proficient, here is a quick reference table of common selectors:<\/p>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\">\n<thead>\n<tr>\n<th>Selector Type<\/th>\n<th>Example<\/th>\n<th>Description<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>CSS Tag<\/td>\n<td><code>response.css('h1')<\/code><\/td>\n<td>Select all &lt;h1&gt; elements<\/td>\n<\/tr>\n<tr>\n<td>CSS Class<\/td>\n<td><code>response.css('.price')<\/code><\/td>\n<td>Select all elements with class &#8220;price&#8221;<\/td>\n<\/tr>\n<tr>\n<td>CSS ID<\/td>\n<td><code>response.css('#main')<\/code><\/td>\n<td>Select the element with id &#8220;main&#8221;<\/td>\n<\/tr>\n<tr>\n<td>CSS Attribute<\/td>\n<td><code>response.css('a[href]')<\/code><\/td>\n<td>Select all anchor elements that have an href attribute<\/td>\n<\/tr>\n<tr>\n<td>XPath Text<\/td>\n<td><code>response.xpath('\/\/p\/text()')<\/code><\/td>\n<td>Extract the text content of all paragraphs<\/td>\n<\/tr>\n<tr>\n<td>XPath Attribute<\/td>\n<td><code>response.xpath('\/\/img\/@src')<\/code><\/td>\n<td>Extract the src attribute of all images<\/td>\n<\/tr>\n<tr>\n<td>XPath Contains<\/td>\n<td><code>response.xpath('\/\/div[contains(@class, \"product\")]')<\/code><\/td>\n<td>Select divs whose class contains &#8220;product&#8221;<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Step 3: Writing Your First Spider<\/h2>\n<h3>Basic Spider Template<\/h3>\n<p>Now that you understand the building blocks, let&#8217;s create a spider that scrapes quotes from the popular demo site <code>http:\/\/quotes.toscrape.com<\/code>. Inside your project&#8217;s <code>spiders<\/code> folder, create a new file called <code>quotes_spider.py<\/code>. Start by importing <code>scrapy<\/code> and defining a class that inherits from <code>scrapy.Spider<\/code>. You must give your spider a unique <code>name<\/code> (used to run it from the command line) and define a list of <code>start_urls<\/code> where the crawling begins. Then, implement the <code>parse<\/code> method, which receives a <code>Response<\/code> object for each downloaded page. Inside <code>parse<\/code>, you will use selectors to extract data and optionally follow links to other pages.<\/p>\n<h3>Extracting Data with Selectors<\/h3>\n<p>For the quotes site, each quote is contained in a <code>div<\/code> with class <code>quote<\/code>. Inside that, the text is in a <code>span<\/code> with class <code>text<\/code>, the author in a <code>small<\/code> with class <code>author<\/code>, and the tags are in <code>a<\/code> elements with class <code>tag<\/code>. Your <code>parse<\/code> method could look like this:<\/p>\n<pre><code>import scrapy\n\nclass QuotesSpider(scrapy.Spider):\n    name = 'quotes'\n    start_urls = ['http:\/\/quotes.toscrape.com']\n\n    def parse(self, response):\n        for quote in response.css('div.quote'):\n            yield {\n                'text': quote.css('span.text::text').get(),\n                'author': quote.css('small.author::text').get(),\n                'tags': quote.css('a.tag::text').getall(),\n            }\n        # Follow pagination link\n        next_page = response.css('li.next a::attr(href)').get()\n        if next_page is not None:\n            yield response.follow(next_page, callback=self.parse)\n<\/code><\/pre>\n<p>Notice how we use <code>yield<\/code> to output a dictionary for each quote. This is the simplest way to store data\u2014Scrapy will automatically collect all yielded items and pass them to the pipeline. The pagination logic uses <code>response.follow<\/code> to build absolute URLs relative to the current page and schedule them for crawling. Run the spider with <code>scrapy crawl quotes -o quotes.json<\/code> to see the results in a JSON file.<\/p>\n<h2>Step 4: Using Items, Item Loaders, and Pipelines<\/h2>\n<h3>Defining Items and Using Item Loaders<\/h3>\n<p>While yielding dictionaries is fine for small projects, larger applications benefit from defining structured <code>Item<\/code> classes in <code>items.py<\/code>. This gives you type safety, better documentation, and the ability to apply processors via Item Loaders. For example, define a <code>QuoteItem<\/code> with fields <code>text<\/code>, <code>author<\/code>, and <code>tags<\/code>. Then, in your spider, import the item and use an <code>ItemLoader<\/code> to populate it:<\/p>\n<pre><code>from scrapy.loader import ItemLoader\nfrom myscraper.items import QuoteItem\n\ndef parse(self, response):\n    for quote in response.css('div.quote'):\n        loader = ItemLoader(item=QuoteItem(), selector=quote)\n        loader.add_css('text', 'span.text::text')\n        loader.add_css('author', 'small.author::text')\n        loader.add_css('tags', 'a.tag::text')\n        yield loader.load_item()\n<\/code><\/pre>\n<p>Item Loaders can also preprocess strings\u2014for instance, stripping whitespace or converting to lowercase\u2014by assigning input and output processors in the item definition.<\/p>\n<h3>Building a Pipeline for Data Cleaning and Storage<\/h3>\n<p>Pipelines are called sequentially for every item that is scraped. To create a pipeline, open <code>pipelines.py<\/code> and define a class with an <code>process_item<\/code> method. This method receives the item and the spider instance, and it must return the item (or raise <code>DropItem<\/code> to discard it). Common tasks include validating required fields, removing HTML tags, converting prices to floats, or storing items in a database. After writing your pipeline, activate it by adding its path to the <code>ITEM_PIPELINES<\/code> setting in <code>settings.py<\/code>. For example:<\/p>\n<pre><code>ITEM_PIPELINES = {\n    'myscraper.pipelines.QuoteValidationPipeline': 300,\n    'myscraper.pipelines.JsonWriterPipeline': 800,\n}\n<\/code><\/pre>\n<p>The number (300, 800) indicates the execution order\u2014lower numbers run first. You can chain multiple pipelines to perform a sequence of operations like cleaning \u2192 deduplication \u2192 storage.<\/p>\n<h2>Step 5: Handling Dynamic Content with Splash and Selenium<\/h2>\n<h3>When JavaScript is Required<\/h3>\n<p>Many modern websites load their primary content via JavaScript after the initial HTML is rendered. Scrapy&#8217;s default downloader only fetches raw HTML, so it cannot see data generated by AJAX calls or client-side frameworks like React or Angular. To scrape such sites, you need a headless browser or a JavaScript rendering service. Two popular approaches are integrating Scrapy with Splash (a lightweight JS rendering service with its own API) or using Selenium WebDriver. Splash is generally preferred because it is designed to work seamlessly with Scrapy via the <code>scrapy-splash<\/code> plugin, and it can also handle Lua scripts for interaction like clicking buttons or waiting for elements.<\/p>\n<h3>Integrating Splash<\/h3>\n<p>First, install the Splash client library: <code>pip install scrapy-splash<\/code>. You will also need to run a Splash Docker container on your machine or use a remote instance. Add the following settings to your <code>settings.py<\/code>:<\/p>\n<pre><code>SPLASH_URL = 'http:\/\/localhost:8050'\nDUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'\nHTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'\n<\/code><\/pre>\n<p>Then, instead of using a standard <code>scrapy.Spider<\/code>, you can use <code>SplashSpider<\/code> or simply apply the <code>SplashRequest<\/code> for specific URLs. A typical snippet looks like:<\/p>\n<pre><code>from scrapy_splash import SplashRequest\n\ndef start_requests(self):\n    yield SplashRequest(url='http:\/\/example.com\/js-page',\n                        callback=self.parse,\n                        args={'wait': 2})  # wait 2 seconds for JS to render\n<\/code><\/pre>\n<p>With Splash, the response object will contain the fully rendered HTML, allowing you to use normal selectors to extract data that appeared only after JavaScript execution.<\/p>\n<h2>Step 6: Advanced Techniques \u2013 Middlewares, Proxies, and Performance Tuning<\/h2>\n<h3>Custom Downloader Middlewares<\/h3>\n<p>Middlewares allow you to modify requests and responses globally. For example, to rotate User-Agent strings and bypass simple bot detection, create a middleware that randomly picks a user agent from a list and adds it to every request. Define a class in <code>middlewares.py<\/code> and activate it in <code>DOWNLOADER_MIDDLEWARES<\/code> setting. Similarly, you can implement proxy rotation by overriding the <code>process_request<\/code> method to assign a proxy from a pool. Here is a minimal example of a user-agent middlewawre:<\/p>\n<pre><code>class RotateUserAgentMiddleware:\n    def __init__(self):\n        self.user_agents = ['Mozilla\/5.0 (Windows NT 10.0; Win64; x64)...', ...]\n\n    def process_request(self, request, spider):\n        request.headers['User-Agent'] = random.choice(self.user_agents)\n<\/code><\/pre>\n<p>Don&#8217;t forget to add <code>'myproject.middlewares.RotateUserAgentMiddleware': 400<\/code> to your settings.<\/p>\n<h3>Concurrency, Delays, and Caching for Performance<\/h3>\n<p>Scrapy&#8217;s asynchronous nature allows it to send many requests concurrently, but sending too many too fast can overwhelm the target server and get you blocked. The settings <code>CONCURRENT_REQUESTS<\/code> (default 16), <code>DOWNLOAD_DELAY<\/code> (delay in seconds between consecutive requests from the same domain), and <code>RANDOMIZE_DOWNLOAD_DELAY<\/code> (adds random jitter) are your primary knobs for polite scraping. For even finer control, consider using <code>AUTOTHROTTLE_ENABLED = True<\/code> which dynamically adjusts concurrency based on server response times. Also enable <code>HTTPCACHE_ENABLED = True<\/code> to cache previously fetched pages, which not only speeds up development but reduces load on the website during debugging.<\/p>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\">\n<thead>\n<tr>\n<th>Setting<\/th>\n<th>Default<\/th>\n<th>Recommendation for Production<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>CONCURRENT_REQUESTS<\/td>\n<td>16<\/td>\n<td>8\u201312 for medium-size sites<\/td>\n<\/tr>\n<tr>\n<td>DOWNLOAD_DELAY<\/td>\n<td>0<\/td>\n<td>1\u20133 seconds to be polite<\/td>\n<\/tr>\n<tr>\n<td>AUTOTHROTTLE_ENABLED<\/td>\n<td>False<\/td>\n<td>True for adaptive politeness<\/td>\n<\/tr>\n<tr>\n<td>HTTPCACHE_ENABLED<\/td>\n<td>False<\/td>\n<td>True during development\/testing<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Step 7: Running and Scheduling Your Spiders<\/h2>\n<h3>Using the Crawl Command<\/h3>\n<p>The simplest way to run a spider is the <code>scrapy crawl<\/code> command from the project root. You already saw <code>scrapy crawl quotes -o quotes.json<\/code>. You can also output to CSV (<code>-o quotes.csv<\/code>) or to a custom feed export. If you need to pass parameters to a spider (e.g., a category URL), you can use the <code>-a<\/code> flag: <code>scrapy crawl quotes -a start_url=\"http:\/\/...\"<\/code> and then access it in your spider via <code>self.start_url<\/code>.<\/p>\n<h3>Deploying to Scrapyd for Remote Execution<\/h3>\n<p>When you want to schedule scrapers on a server, Scrapyd is the official solution. Install scrapyd (<code>pip install scrapyd<\/code>) and start the daemon with <code>scrapyd<\/code>. Then deploy your project with <code>scrapyd-deploy<\/code> and schedule a spider via the HTTP API. Alternatively, you can use cron jobs on a Linux server to execute <code>scrapy crawl<\/code> commands at regular intervals. For cloud-scale scraping, consider services like Scrapy Cloud (Zyte) or deploying inside Docker containers.<\/p>\n<h2>Tips and Best Practices<\/h2>\n<h3>1. Always Respect robots.txt and Define a Crawling Policy<\/h3>\n<p>Robots.txt files indicate which parts of a website you are allowed to crawl. While Scrapy automatically respects <code>ROBOTSTXT_OBEY = True<\/code> (set by default), you should verify that your spider is not violating any terms of service. For large-scale scraping, implement a custom policy that throttles requests and avoids private areas of the site.<\/p>\n<h3>2. Use Item Loaders with Processors to Ensure Data Quality<\/h3>\n<p>Raw scraped data often contains extra whitespace, HTML entities, or inconsistent formatting. By using Item Loaders with processors like <code>TakeFirst()<\/code>, <code>MapCompose()<\/code>, and <code>Join()<\/code>, you can clean and normalize data before it ever reaches your output file. This saved us countless hours of manual cleanup.<\/p>\n<h3>3. Implement Robust Error Handling and Retries<\/h3>\n<p>Not every request will succeed\u2014servers can timeout, return 500 errors, or redirect to login pages. Configure <code>RETRY_TIMES<\/code> (default 2) and <code>RETRY_HTTP_CODES<\/code> to automatically retry on transient errors. Additionally, use <code>scrapy.extensions.closespider.Extension<\/code> to stop the spider after a certain number of errors to avoid infinite loops.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Q1: How do I fix &#8220;ModuleNotFoundError: No module named &#8216;scrapy'&#8221; after installation?<\/h3>\n<p>This usually indicates that pip installed Scrapy into a different Python environment than the one you are using. Make sure you are running <code>scrapy<\/code> from the same Python interpreter where it was installed. Using a virtual environment (e.g., venv or conda) and activating it before running your spider avoids this confusion.<\/p>\n<h3>Q2: My spider is extracting empty fields \u2013 what&#8217;s wrong?<\/h3>\n<p>First, verify that your selectors are correct by opening the page in a browser and inspecting the element. Common issues include: the page is dynamically loaded and Scrapy sees only the HTML skeleton (use Splash), the class names are complex or change on each visit (try more general XPath expressions), or the website uses a different HTML structure than you assumed. Use the Scrapy shell (<code>scrapy shell 'url'<\/code>) to test selectors interactively.<\/p>\n<h3>Q3: How can I bypass CAPTCHA blocking?<\/h3>\n<p>CAPTCHA implementation is a sign that the website actively blocks scrapers. The best approach is to look for an official API instead of scraping. If you must scrape, consider using CAPTCHA-solving services (e.g., 2Captcha) integrated via middleware, or implement human-like behavior such as random delays, realistic user agents, and session maintenance through cookies. Note that scraping sites with CAPTCHA may violate their terms of service.<\/p>\n<h3>Q4: Can I scrape websites that require login?<\/h3>\n<p>Yes, Scrapy can handle authentication. You can send a POST request with the login form data using <code>FormRequest.from_response()<\/code> to simulate form submission, or manually set cookies after logging in via a browser. Remember to store the logged-in session using a cookie jar. Example code: <code>return FormRequest.from_response(response, formdata={'username': 'user', 'password': 'pass'}, callback=self.after_login)<\/code><\/p>\n<h3>Q5: How do I pause and resume a long-running crawl?<\/h3>\n<p>Scrapy supports job pausing via the <code>JOBDIR<\/code> setting. Run your spider with <code>scrapy crawl quotes -s JOBDIR=jobs\/quotes-1<\/code>. If you interrupt the process (Ctrl+C), Scrapy will save its state. You can resume by running the same command again. This is extremely useful for large crawls that may take hours or days.<\/p>\n<h2>Conclusion<\/h2>\n<p>Throughout this tutorial, you have learned how to harness the full power of Scrapy for web scraping\u2014from setting up a project and writing your first spider to handling complex dynamic content and optimizing performance with middlewares and pipelines. Scrapy&#8217;s modular design ensures that you can start small with a simple <code>parse<\/code> method and gradually incorporate advanced features as your scraping needs grow. Remember that effective scraping is not just about code; it is also about understanding the websites you target, respecting their rate limits and terms of use, and ensuring your data collection is ethical and legal. With the knowledge you have gained here, you are now equipped to build robust, maintainable, and scalable scrapers that can extract data from almost any website on the internet. Always test your spiders thoroughly, leverage the powerful Scrapy shell for debugging, and never underestimate the importance of good selectors. Happy scraping!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>The Ultimate Guide to Web Scraping with Scrapy: From Installation to Advanced Techniques Web scraping has become an indispensable tool for data-driven decision-making in modern business, research, and development. Whether you are monitoring competitor prices, aggregating news articles, building a dataset for machine learning, or simply automating the collection of online information, the need for &hellip; <\/p>\n","protected":false},"author":2716,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"footnotes":""},"categories":[],"tags":[],"class_list":["post-988","post","type-post","status-publish","format-standard","hentry"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/988","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/users\/2716"}],"replies":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/comments?post=988"}],"version-history":[{"count":0,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/988\/revisions"}],"wp:attachment":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/media?parent=988"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/categories?post=988"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/tags?post=988"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}