{"id":1064,"date":"2026-07-02T06:51:53","date_gmt":"2026-07-01T23:51:53","guid":{"rendered":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/02\/building-a-custom-search-engine-a-step-by-step-guide-from-concept-to-deployment\/"},"modified":"2026-07-02T06:51:53","modified_gmt":"2026-07-01T23:51:53","slug":"building-a-custom-search-engine-a-step-by-step-guide-from-concept-to-deployment","status":"publish","type":"post","link":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/02\/building-a-custom-search-engine-a-step-by-step-guide-from-concept-to-deployment\/","title":{"rendered":"Building a Custom Search Engine: A Step-by-Step Guide from Concept to Deployment"},"content":{"rendered":"<h1>Building a Custom Search Engine: A Step-by-Step Guide from Concept to Deployment<\/h1>\n<h2>Introduction<\/h2>\n<p>In an era where information overload is the norm, having the ability to search through your own data quickly and accurately is a superpower. A custom search engine goes far beyond the generic search box provided by WordPress or a basic database query; it gives you full control over how content is indexed, ranked, and retrieved. Whether you are building a documentation portal for your SaaS product, a vertical search engine for a niche industry, an internal knowledge base for your company, or even a personal bookmark manager, creating your own search engine allows you to tailor relevance rules, handle synonyms, filter by custom fields, and scale to millions of documents without paying per-query fees to third-party services. This tutorial will walk you through the entire process of building a production\u2011ready custom search engine using modern open\u2011source tools, specifically Meilisearch, which is known for its speed, ease of use, and developer\u2011friendly APIs.<\/p>\n<p>The approach we will take is pragmatic and hands\u2011on. We will start by defining what kind of data you want to search and where it lives. Next, we\u2019ll set up Meilisearch \u2013 either on your own server or using their cloud offering. Then we will write a simple crawler to scrape web pages or import JSON\/CSV files, and index that data into Meilisearch. After indexing, we\u2019ll fine\u2011tune the search parameters such as ranking rules, typo tolerance, and filterable attributes. Finally, we\u2019ll build a frontend search interface with React and InstantSearch, deploy everything with Docker, and discuss monitoring and maintenance. Along the way, we will include best practices for performance, security, and user experience. By the end, you will have a fully functional custom search engine that you can extend and customise for any use case.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/via.placeholder.com\/800x600\/4a90d9\/ffffff?text=how%20to%20build%20a%20custom%20search%20engine\" alt=\"Article illustration\" style=\"display:block;margin:20px auto;max-width:100%;height:auto;border-radius:8px;\" \/><\/p>\n<h2>Step\u2011by\u2011Step Guide to Building Your Custom Search Engine<\/h2>\n<h3>Step 1: Define Your Requirements and Data Sources<\/h3>\n<p>Before writing a single line of code, you must answer the fundamental questions: What exactly are you searching? Where does the data reside? How often does it change? And what kind of search experience do your users expect? For example, if you are building a search engine for an e\u2011commerce site, you might want to index product names, descriptions, categories, prices, and availability. You may also need faceted filtering (by brand, size, colour) and a ranking that boosts products with higher ratings. If you are indexing a documentation site, you might prioritise exact title matches over fuzzy body matches and support search\u2011as\u2011you\u2011type. The data source could be a database (PostgreSQL, MySQL), a set of HTML files on disk, a CMS like WordPress via its REST API, or even a collection of PDFs that need to be text\u2011extracted. For this tutorial, we will assume a typical scenario: you have a collection of web pages (a documentation site) and you want to provide instant, typo\u2011tolerant search. You will need to crawl those pages, extract the text content, and index it along with metadata such as the page URL and title. Make sure you understand your data\u2019s structure thoroughly \u2013 it will affect how you configure the index schema later.<\/p>\n<h3>Step 2: Install and Configure Meilisearch<\/h3>\n<p>Meilisearch is an open\u2011source, Rust\u2011based search engine that is incredibly fast out of the box. It provides near\u2011instantaneous results, typo tolerance, faceted search, and a simple REST API. You can run it locally on your machine for development or deploy it on a VPS using Docker. The easiest way to get started is to use the official Docker image. Run the following command to start a Meilisearch container:<\/p>\n<p><code>docker run -it --rm -p 7700:7700 -v $(pwd)\/meili_data:\/meili_data getmeili\/meilisearch:v1.8<\/code><\/p>\n<p>This will expose the search engine on port 7700 and persist data in a local folder named <code>meili_data<\/code>. Once the container is running, open <strong>http:\/\/localhost:7700<\/strong> in your browser. You will see a neat dashboard where you can monitor indexes, settings, and API keys. By default, Meilisearch starts without a master key \u2013 but for production you absolutely must set an environment variable <code>MEILI_MASTER_KEY<\/code> to a strong random string. The master key is used to generate API keys with different permission levels. For development, you can skip this, but we will cover secure deployment later. After installation, test that the server responds by sending a curl request:<\/p>\n<p><code>curl -X GET 'http:\/\/localhost:7700\/health'<\/code><\/p>\n<p>You should receive a JSON response with status &#8220;available&#8221;. Now you are ready to create your first index.<\/p>\n<h3>Step 3: Crawl, Extract, and Index Your Data<\/h3>\n<p>To populate your search engine, you need to feed it with documents. A document in Meilisearch is a JSON object with an <code>id<\/code> field and any other attributes you want to make searchable. For our documentation site, we will write a Python scraper using <code>requests<\/code> and <code>BeautifulSoup<\/code> that extracts the title, URL, and text content from each page. We\u2019ll also add a <code>last_updated<\/code> timestamp to help with re\u2011indexing. The scraper will start from a sitemap or a list of seed URLs, follow same\u2011domain links up to a certain depth, and avoid duplicates. After gathering all pages, we transform each page into a document like this:<\/p>\n<pre>\n{\n  \"id\": 1,\n  \"title\": \"Getting Started\",\n  \"url\": \"https:\/\/docs.example.com\/getting-started\",\n  \"content\": \"Welcome to our documentation. This guide...\",\n  \"last_updated\": \"2025-03-01T12:00:00Z\"\n}\n<\/pre>\n<p>Then we send these documents to Meilisearch using its <code>\/indexes\/{index_uid}\/documents<\/code> endpoint. For example, using Python and the <code>meilisearch<\/code> module:<\/p>\n<pre>\nimport meilisearch\nclient = meilisearch.Client('http:\/\/localhost:7700')\nindex = client.index('docs')\nindex.add_documents(documents_list)\n<\/pre>\n<p>You can also use the curl command:<\/p>\n<p><code>curl -X POST 'http:\/\/localhost:7700\/indexes\/docs\/documents' --header 'Content-Type: application\/json' --data @documents.json<\/code><\/p>\n<p>One important aspect is that you should chunk large documents \u2013 especially if a single page contains more than 10,000 words \u2013 because Meilisearch works best with small\u2011to\u2011medium sized documents. For very long pages, split them into sections (e.g., by headings) and treat each section as a separate document, keeping the parent URL as a group identifier. After indexing, you can verify the number of documents using the <code>\/indexes\/docs\/stats<\/code> endpoint.<\/p>\n<h3>Step 4: Fine\u2011Tune Search Settings and Ranking<\/h3>\n<p>Meilisearch is designed to work well with default settings, but every custom search engine benefits from tuning. The two most important areas are <strong>ranking rules<\/strong> and <strong>attribute configuration<\/strong>. By default, Meilisearch ranks documents using: (1) word proximity, (2) typo, (3) words position, (4) exactness, (5) proximity (again), and (6) sort. You can change the order and add custom ranking rules based on numeric or boolean fields. For our documentation index, we probably want to give extra weight to the <code>title<\/code> field so that an exact title match appears first. This is done by adjusting the <strong>searchable attributes<\/strong> order \u2013 put <code>title<\/code> first, then <code>content<\/code>.<\/p>\n<p>To set searchable attributes, send a PATCH request to <code>\/indexes\/docs\/settings<\/code> with JSON: <code>{\"searchableAttributes\": [\"title\", \"content\"]}<\/code>. Next, configure <strong>filterable attributes<\/strong> \u2013 if you want users to filter by something like category or author. For our use case, we can add <code>url<\/code> as a filterable attribute (though unlikely). Also enable <strong>faceted search<\/strong> by adding the field to <code>filterableAttributes<\/code>. Another crucial setting is <strong>typo tolerance<\/strong>. Meilisearch automatically handles typos, but you can adjust the minimum word size for typo correction or disable it entirely for exact match requirements. For a documentation site, typo tolerance is a great feature because users often misspell terms. However, you may want to reduce the number of typos allowed for short words. Use the settings endpoint to modify <code>typoTolerance<\/code> object.<\/p>\n<p>Finally, consider adding <strong>synonyms<\/strong>. If your domain uses specific terminology, synonyms can improve search relevance. For example, adding &#8220;install&#8221; as a synonym of &#8220;setup&#8221; ensures both words return the same documents. Synonyms are also configured through the settings endpoint.<\/p>\n<p>To test your configuration, perform a few sample queries using the frontend or curl. For instance:<\/p>\n<p><code>curl -X POST 'http:\/\/localhost:7700\/indexes\/docs\/search' --data '{\"q\": \"install\", \"attributesToHighlight\": [\"*\"]}'<\/code><\/p>\n<p>Examine the <code>_formatted<\/code> field to see highlighted matches. Tweak until the results feel natural.<\/p>\n<h3>Step 5: Build a Frontend Search Interface<\/h3>\n<p>With the backend ready, it\u2019s time to create a user interface. Meilisearch provides several frontend libraries, with the most popular being <strong>InstantSearch<\/strong> (Algolia\u2019s library) which works seamlessly with Meilisearch through a dedicated connector. For this tutorial, we will build a simple React app. Start by creating a new React project with <code>create-react-app<\/code> and install the dependencies:<\/p>\n<pre>\nnpm install react-instantsearch-hooks @meilisearch\/instant-meilisearch\n<\/pre>\n<p>Then, in your main <code>App.js<\/code>, set up the Meilisearch client and wrap your components with <code>InstantSearch<\/code>. Here is a minimal example:<\/p>\n<pre>\nimport { InstantSearch, SearchBox, Hits, Highlight } from 'react-instantsearch-hooks';\nimport { instantMeiliSearch } from '@meilisearch\/instant-meilisearch';\n\nconst searchClient = instantMeiliSearch(\n  \"http:\/\/localhost:7700\",\n  \"your-api-key\" \/\/ use a public search-only API key for security\n);\n\nfunction App() {\n  return (\n    <InstantSearch indexName=\"docs\" searchClient={searchClient}>\n      <SearchBox \/>\n      <Hits hitComponent={Hit} \/>\n    <\/InstantSearch>\n  );\n}\n\nfunction Hit({ hit }) {\n  return (\n    <article>\n      <h2><Highlight attribute=\"title\" hit={hit} \/><\/h2>\n      <p><Highlight attribute=\"content\" hit={hit} \/><\/p>\n      <a href={hit.url}>Read more<\/a>\n    <\/article>\n  );\n}\n<\/pre>\n<p>This produces a basic search box and a list of results with highlighted matching terms. For production, you will want to add pagination, faceted filters, and a more polished design. You can also use the <code>refinement-list<\/code> component if you have filterable attributes. The incredible advantage of using InstantSearch is that it handles state management, debouncing, and analytics out of the box. If you prefer not to use React, Meilisearch also provides a vanilla JavaScript widget called <code>docs-searchbar<\/code> that works with any framework. The frontend is also a good place to implement search\u2011as\u2011you\u2011type (which is enabled by default) and to customise the empty state and error handling.<\/p>\n<h3>Step 6: Deploy, Secure, and Monitor<\/h3>\n<p>Now that your custom search engine works locally, it\u2019s time to deploy it. The recommended approach is to use Docker Compose for both Meilisearch and your frontend (served with Nginx). Create a <code>docker-compose.yml<\/code> file that defines two services: <code>search<\/code> (Meilisearch) and <code>web<\/code> (your React app built as static files). For Meilisearch, remember to set the <code>MEILI_MASTER_KEY<\/code> environment variable and use a persistent volume. For security, generate separate API keys: a <strong>private<\/strong> key for indexing (with permissions to add\/delete documents) and a <strong>public<\/strong> key for search queries (restricted to search only). Pass the public key to your frontend via environment variables at build time. Also, consider enabling HTTPS using a reverse proxy like Caddy or Nginx with Let\u2019s Encrypt. Meilisearch itself does not handle HTTPS, so you should put it behind a proxy that terminates TLS.<\/p>\n<p>Monitoring is another vital part. Meilisearch exposes metrics in Prometheus format at <code>\/metrics<\/code>. You can set up Prometheus and Grafana to track query latency, memory usage, and index size. Additionally, set up log rotation for Meilisearch logs and configure alerts if the instance goes down. For re\u2011indexing, you can run your crawler periodically (e.g., via a cron job inside the same Docker network) and use the <code>update documents<\/code> endpoint with partial documents to refresh only changed fields. If your data changes frequently, consider using webhooks or a message queue to stream updates in near real\u2011time. Finally, test your deployment by performing a few hundred queries and observing the response times \u2013 Meilisearch should respond in under 50ms even with millions of documents.<\/p>\n<h2>Tips and Best Practices<\/h2>\n<h3>1. Start with Small, Representative Data<\/h3>\n<p>When you first build your custom search engine, do not immediately index your entire dataset of 10 million records. Begin with a few hundred well\u2011chosen documents that cover the variety of content you have. This makes it much faster to iterate on settings, synonyms, and ranking rules. You can test relevance manually by writing a list of expected queries and checking that the top result is what you would expect. Once the small index works perfectly, scale up gradually. Meilisearch can handle large indexes (hundreds of millions of documents), but the configuration phase is much more productive with a small subset.<\/p>\n<h3>2. Optimize for Typo Tolerance Carefully<\/h3>\n<p>Typo tolerance is one of Meilisearch\u2019s strongest features, but it can also return irrelevant results if not tuned. For example, if a user types \u201cinstal\u201d instead of \u201cinstall\u201d, the engine will correct it. However, if you have a very short word like \u201ccpu\u201d, you may want to disable typo correction for words with fewer than 4 characters to avoid false positives. You can set <code>typoTolerance.minWordSizeForTypos<\/code> to <code>4<\/code> in the settings. Also, consider whether you need <strong>exact<\/strong> matching for certain fields like product codes. For those, you can set the field as a <strong>non\u2011searchable attribute<\/strong> and instead use it only as a filter. Another tip: enable <strong>split\u2011by\u2011case<\/strong> if your data contains CamelCase words \u2013 it helps with partial matching.<\/p>\n<h3>3. Implement Highlighting and Snippets<\/h3>\n<p>Users love to see why a particular document matched their query. Use the <code>attributesToHighlight<\/code> parameter in your search requests to get formatted results with <code><em><\/code> tags around matched terms. In the frontend, you can render these raw HTML strings using <code>dangerouslySetInnerHTML<\/code> in React (make sure to sanitize if needed). For long content, also request <code>attributesToCrop<\/code> to get a snippet of text around the match. This improves the user\u2019s ability to scan quickly. Additionally, display the full URL and timestamp of the last update to build trust.<\/p>\n<h2>FAQ Section<\/h2>\n<h3>Q1: Can I build a custom search engine without any coding?<\/h3>\n<p>Yes, if you use a managed service like Google Custom Search or Algolia, you can create a search engine with very little coding \u2013 just some HTML and JavaScript to embed the search widget. However, for full control over indexing, ranking, and data privacy, open\u2011source engines like Meilisearch require some programming (at least for the crawler and frontend). This tutorial assumes you are comfortable with basic Python and React, but you can also use Meilisearch\u2019s built\u2011in dashboard for simple operations if you have a small dataset.<\/p>\n<h3>Q2: How do I crawl an entire website for indexing?<\/h3>\n<p>You can write a crawler using Python with libraries like <code>requests<\/code>, <code>BeautifulSoup<\/code>, and <code>crawler\u2011utils<\/code>. Alternatively, use ready\u2011made tools like <code>scrapy<\/code> or <code>colly<\/code> (Go). The key is to respect <code>robots.txt<\/code>, set a reasonable crawl delay, and avoid duplicate pages (use URL canonicalization). For static sites, you can also generate a sitemap and parse it. Remember to extract only the content areas (e.g., <code><main><\/code> or <code><\/p>\n<article><\/code>) to avoid indexing navigation bars and footers.<\/p>\n<h3>Q3: How do I handle multilingual content?<\/h3>\n<p>Meilisearch does not have built\u2011in language detection, but you can handle it by either creating separate indexes per language (e.g., <code>docs_en<\/code>, <code>docs_fr<\/code>) or by including a language field in every document and filtering by that field in the frontend. For tokenization, Meilisearch uses a character\u2011based approach that works reasonably well for most languages, but for specific languages like Chinese or Japanese you may need to pre\u2011segment words. You can also enable the <code>localizedAttributes<\/code> setting to improve ranking by recognizing certain languages.<\/p>\n<h3>Q4: Is Meilisearch free for commercial use?<\/h3>\n<p>Yes, Meilisearch is open source under the MIT license, which means you can use it for any commercial project without paying licensing fees. However, if you use their cloud offering (Meilisearch Cloud), you pay based on usage. Self\u2011hosting is free, but you incur server costs. Additionally, certain advanced features like federated search across multiple instances are only available in the cloud version.<\/p>\n<h3>Q5: How do I re\u2011index only changed documents?<\/h3>\n<p>Meilisearch supports <strong>partial document updates<\/strong> \u2013 you can send a document with only the fields that changed, and the engine merges them. To efficiently detect changes, you need a mechanism: for a database, you can query a <code>updated_at<\/code> column; for web pages, you can compare <code>last-modified<\/code> headers or content hashes. Then you batch the changed documents and call the <code>update documents<\/code> API. If you need to delete stale pages, use the <code>delete documents<\/code> endpoint by ID. This incremental approach is much faster than a full re\u2011index every time.<\/p>\n<h2>Reference Tables<\/h2>\n<table border=\"1\" cellpadding=\"5\" cellspacing=\"0\">\n<caption><strong>Comparison of Open\u2011Source Search Engines<\/strong><\/caption>\n<thead>\n<tr>\n<th>Engine<\/th>\n<th>Language<\/th>\n<th>Typo Tolerance<\/th>\n<th>Performance (1M docs)<\/th>\n<th>Ease of Setup<\/th>\n<th>Query Language<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Meilisearch<\/td>\n<td>Rust<\/td>\n<td>Built\u2011in, configurable<\/td>\n<td>< 50ms<\/td>\n<td>Very easy (Docker)<\/td>\n<td>JSON API \/ Rust SDK<\/td>\n<\/tr>\n<tr>\n<td>Elasticsearch<\/td>\n<td>Java<\/td>\n<td>Requires custom analyzer<\/td>\n<td>~100ms<\/td>\n<td>Moderate (complex config)<\/td>\n<td>JSON \/ Lucene query<\/td>\n<\/tr>\n<tr>\n<td>Apache Solr<\/td>\n<td>Java<\/td>\n<td>Via custom plugins<\/td>\n<td>~150ms<\/td>\n<td>Moderate<\/td>\n<td>HTTP \/ Solr query<\/td>\n<\/tr>\n<tr>\n<td>Typesense<\/td>\n<td>C++<\/td>\n<td>Built\u2011in<\/td>\n<td>< 50ms<\/td>\n<td>Very easy<\/td>\n<td>JSON API<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<table border=\"1\" cellpadding=\"5\" cellspacing=\"0\">\n<caption><strong>Key Meilisearch Configuration Parameters<\/strong><\/caption>\n<thead>\n<tr>\n<th>Parameter<\/th>\n<th>Type<\/th>\n<th>Description<\/th>\n<th>Example Value<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>searchableAttributes<\/td>\n<td>Array of strings<\/td>\n<td>Fields that are searchable, in order of priority.<\/td>\n<td>[&#8220;title&#8221;,&#8221;content&#8221;]<\/td>\n<\/tr>\n<tr>\n<td>filterableAttributes<\/td>\n<td>Array of strings<\/td>\n<td>Fields that can be used for filtering.<\/td>\n<td>[&#8220;category&#8221;,&#8221;date&#8221;]<\/td>\n<\/tr>\n<tr>\n<td>sortableAttributes<\/td>\n<td>Array of strings<\/td>\n<td>Fields that can be used for sorting results.<\/td>\n<td>[&#8220;date&#8221;,&#8221;rating&#8221;]<\/td>\n<\/tr>\n<tr>\n<td>rankingRules<\/td>\n<td>Array of strings<\/td>\n<td>Order of ranking criteria.<\/td>\n<td>[&#8220;words&#8221;,&#8221;typo&#8221;,&#8221;proximity&#8221;,&#8221;attribute&#8221;,&#8221;exactness&#8221;,&#8221;sort&#8221;]<\/td>\n<\/tr>\n<tr>\n<td>typoTolerance<\/td>\n<td>Object<\/td>\n<td>Controls typo correction behavior.<\/td>\n<td>{&#8220;enabled&#8221;:true,&#8221;minWordSizeForTypos&#8221;:{&#8220;oneTypo&#8221;:5,&#8221;twoTypos&#8221;:9}}<\/td>\n<\/tr>\n<tr>\n<td>synonyms<\/td>\n<td>Object<\/td>\n<td>Map of synonym groups.<\/td>\n<td>{&#8220;install&#8221;:[&#8220;setup&#8221;,&#8221;configure&#8221;]}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Conclusion<\/h2>\n<p>Building a custom search engine may sound like a daunting task reserved for large tech companies, but with modern open\u2011source tools like Meilisearch, it is entirely achievable by a single developer or a small team. In this tutorial, we have covered the full lifecycle: from understanding your data and setting up a lightning\u2011fast backend, to crawling and indexing content, tuning relevance, building a glossy frontend with InstantSearch, and deploying securely. The beauty of a custom search engine is that you are not tied to third\u2011party pricing models or closed ecosystems \u2013 you own your indexing pipeline, your ranking logic, and your data. As you become more comfortable, you can extend the engine with advanced features such as personalisation (by user history), semantic search (using embeddings), or even a hybrid search that combines keyword and vector search. The key takeaway is to start simple, test relentlessly with real queries, and iterate on the feedback loop. Your users will thank you for the fast, relevant, and truly custom search experience. Now go ahead and build your own \u2013 the internet is your oyster.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Building a Custom Search Engine: A Step-by-Step Guide from Concept to Deployment Introduction In an era where information overload is the norm, having the ability to search through your own data quickly and accurately is a superpower. A custom search engine goes far beyond the generic search box provided by WordPress or a basic database &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-1064","post","type-post","status-publish","format-standard","hentry"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1064","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=1064"}],"version-history":[{"count":0,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1064\/revisions"}],"wp:attachment":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/media?parent=1064"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/categories?post=1064"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/tags?post=1064"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}