{"id":6505,"date":"2023-12-19T09:54:28","date_gmt":"2023-12-19T16:54:28","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=6505"},"modified":"2023-12-19T09:54:59","modified_gmt":"2023-12-19T16:54:59","slug":"timeout-linux-command","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/timeout-linux-command\/","title":{"rendered":"Linux &#8216;timeout&#8217; Command | Syntax, Tips, and Examples"},"content":{"rendered":"<div class=\"wp-block-image\">\n<figure class=\"alignright size-full is-resized\"><img decoding=\"async\" src=\"https:\/\/ioflood.com\/blog\/wp-content\/uploads\/2023\/12\/Graphic-depiction-of-a-Linux-terminal-with-the-timeout-command-focusing-on-limiting-process-execution-time-300x300.jpg\" alt=\"Graphic depiction of a Linux terminal with the timeout command focusing on limiting process execution time\" width=\"300\" height=\"300\" title=\"\"><\/figure>\n<\/div>\n<p>Are you finding it challenging to manage long-running processes in Linux? You&#8217;re not alone. Many system administrators and developers grapple with this task, but there&#8217;s a tool that can make this process a breeze.<\/p>\n<p>Like a vigilant supervisor, the &#8216;timeout&#8217; command in Linux is a handy utility that can seamlessly control processes that run longer than expected. These commands can be a lifesaver in managing system resources and ensuring smooth operation of your Linux system.<\/p>\n<p><strong>This guide will walk you through the basics to advanced usage of the &#8216;timeout&#8217; command in Linux.<\/strong> We\u2019ll explore &#8216;timeout&#8217;s core functionality, delve into its advanced features, and even discuss common issues and their solutions.<\/p>\n<p>So, let&#8217;s dive in and start mastering the &#8216;timeout&#8217; command in Linux!<\/p>\n<h2>TL;DR: How Do I Use the Timeout Command in Linux?<\/h2>\n<blockquote><p>\n  The <code>'timeout'<\/code> command in Linux is used to terminate a process after a certain period of time. You can use it to automatically stop a script or command after a specified duration. For instance, <code>timeout [time] .\/sample_script.sh<\/code> will terminate the script &#8216;sample_script.sh&#8217; if it runs for more than the specified amount of time.\n<\/p><\/blockquote>\n<p>Here&#8217;s a simple example:<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout 10s .\/your_script.sh\n\n# Output:\n# Terminates the script 'your_script.sh' if it runs for more than 10 seconds.\n<\/code><\/pre>\n<p>In this example, we use the &#8216;timeout&#8217; command to stop the execution of &#8216;your_script.sh&#8217; if it exceeds 10 seconds. This is particularly useful when you have scripts or commands that may potentially run indefinitely and consume system resources.<\/p>\n<blockquote><p>\n  This is just a basic way to use the &#8216;timeout&#8217; command in Linux, but there&#8217;s much more to learn about managing and controlling process timeouts effectively. Continue reading for more detailed information and advanced usage scenarios.\n<\/p><\/blockquote>\n<h2>Basic Use of the Timeout Command<\/h2>\n<p>The &#8216;timeout&#8217; command in Linux is a utility that allows you to set a time limit for a process to run. After the specified time has passed, if the process is still running, &#8216;timeout&#8217; will terminate it.<\/p>\n<p>The basic syntax of the &#8216;timeout&#8217; command is as follows:<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout [OPTION] DURATION COMMAND\n<\/code><\/pre>\n<ul>\n<li><code>OPTION<\/code> is optional and represents additional parameters you can pass to the command. We&#8217;ll get into this in the advanced section.<\/li>\n<li><code>DURATION<\/code> is the time limit you want to set for the process. This can be specified in seconds (s), minutes (m), hours (h), or days (d).<\/li>\n<li><code>COMMAND<\/code> is the process you want to run with a time limit.<\/li>\n<\/ul>\n<p>Now, let&#8217;s look at a simple example. Suppose you have a script that fetches data from a remote server, and you want to ensure it doesn&#8217;t run for more than 2 minutes. Here&#8217;s how you can achieve that:<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout 2m .\/fetch_data.sh\n\n# Output:\n# If the fetch_data.sh script runs for more than 2 minutes, it will be terminated.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command will stop the execution of &#8216;fetch_data.sh&#8217; if it exceeds 2 minutes. This is a simple yet powerful way to prevent long-running processes from consuming too many system resources.<\/p>\n<p>However, it&#8217;s important to note that the &#8216;timeout&#8217; command will not prevent a process from starting if it&#8217;s likely to exceed the specified duration. It only monitors running processes and terminates them if they exceed the set time limit.<\/p>\n<h2>Advanced Use: Linux Timeout<\/h2>\n<p>As you become more comfortable with the basic usage of the &#8216;timeout&#8217; command in Linux, you&#8217;ll find that its true power lies in its advanced features. These include specifying time in different units (seconds, minutes, hours, etc.), sending a specific signal after timeout, and more.<\/p>\n<p>Before we dive into the advanced usage of the &#8216;timeout&#8217; command, let&#8217;s familiarize ourselves with some of the command-line arguments or flags that can modify the behavior of the &#8216;timeout&#8217; command. Here&#8217;s a table with some of the most commonly used &#8216;timeout&#8217; arguments:<\/p>\n<table>\n<thead>\n<tr>\n<th>Argument<\/th>\n<th>Description<\/th>\n<th>Example<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>-s<\/code><\/td>\n<td>Specifies the signal to be sent on timeout.<\/td>\n<td><code>timeout -s HUP 30m .\/script.sh<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>-k<\/code><\/td>\n<td>Specifies the kill signal to be sent after a grace period.<\/td>\n<td><code>timeout -k 5s 30m .\/script.sh<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>--preserve-status<\/code><\/td>\n<td>Exit with the same status as COMMAND, even when the command times out.<\/td>\n<td><code>timeout --preserve-status 30m .\/script.sh<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>--foreground<\/code><\/td>\n<td>When not running timeout directly from a shell prompt, allow COMMAND to read from the TTY and get TTY signals.<\/td>\n<td><code>timeout --foreground 30m .\/interactive_script.sh<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>-v<\/code>, <code>--verbose<\/code><\/td>\n<td>Diagnose to stderr any signal sent upon timeout.<\/td>\n<td><code>timeout -v 30m .\/script.sh<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>-h<\/code>, <code>--help<\/code><\/td>\n<td>Display a help message and exit.<\/td>\n<td><code>timeout --help<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>-V<\/code>, <code>--version<\/code><\/td>\n<td>Output version information and exit.<\/td>\n<td><code>timeout --version<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Now that we have a basic understanding of &#8216;timeout&#8217; command line arguments, let&#8217;s dive deeper into the advanced use of &#8216;timeout&#8217;.<\/p>\n<h3>Specifying Time in Different Units<\/h3>\n<p>The &#8216;timeout&#8217; command allows you to specify the duration in different units. This can be particularly useful when you need to set a precise time limit for a process. Here&#8217;s an example:<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout 1h30m .\/long_running_script.sh\n\n# Output:\n# If the long_running_script.sh script runs for more than 1 hour and 30 minutes, it will be terminated.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command will stop the execution of &#8216;long_running_script.sh&#8217; if it exceeds 1 hour and 30 minutes.<\/p>\n<h3>Sending a Specific Signal After Timeout<\/h3>\n<p>By default, the &#8216;timeout&#8217; command sends a TERM signal to the process when the time limit is reached. However, you can specify a different signal using the <code>-s<\/code> option. Here&#8217;s an example:<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout -s HUP 30m .\/script.sh\n\n# Output:\n# If the script.sh runs for more than 30 minutes, a HUP signal will be sent to it.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command will send a HUP signal to &#8216;script.sh&#8217; if it runs for more than 30 minutes. The HUP signal is often used to tell a process to restart and re-read its configuration files.<\/p>\n<p>These are just a few examples of the advanced features of the &#8216;timeout&#8217; command in Linux. By harnessing these features, you can have greater control over your processes and manage your system resources more effectively.<\/p>\n<h2>Alternatives to the Timeout Command<\/h2>\n<p>While the &#8216;timeout&#8217; command is a powerful tool for managing process durations in Linux, it&#8217;s not the only method available. Let&#8217;s explore some alternative techniques to achieve process timeout, including the use of the &#8216;kill&#8217; command with &#8216;sleep&#8217;, and third-party tools.<\/p>\n<h3>Using the &#8216;kill&#8217; Command with &#8216;sleep&#8217;<\/h3>\n<p>The &#8216;kill&#8217; command in Linux is used to send a specific signal to the given process. The &#8216;sleep&#8217; command pauses the execution of the next command for a specified amount of time. We can use these two commands in conjunction to achieve a similar result as the &#8216;timeout&#8217; command. Here&#8217;s how:<\/p>\n<pre><code class=\"language-bash line-numbers\">.\/long_running_script.sh &amp; sleep 30m ; kill $!\n\n# Output:\n# Runs the long_running_script.sh in the background, waits for 30 minutes, and then kills the process if it is still running.\n<\/code><\/pre>\n<p>In this example, the script &#8216;long_running_script.sh&#8217; runs in the background, and the &#8216;sleep&#8217; command pauses the execution for 30 minutes. If the script is still running after this time, the &#8216;kill&#8217; command terminates it. This method provides a workaround for systems that may not have the &#8216;timeout&#8217; command installed.<\/p>\n<p>However, it&#8217;s important to note that this method does not work exactly like the &#8216;timeout&#8217; command. The &#8216;kill&#8217; command will terminate the process after the sleep duration, regardless of when the process started. So, if the process finishes before the sleep duration ends, the &#8216;kill&#8217; command will have no effect.<\/p>\n<h3>Using Third-Party Tools<\/h3>\n<p>There are several third-party tools available that can help you manage process timeouts in Linux. One such tool is &#8216;Timelimit&#8217;. It works similarly to the &#8216;timeout&#8217; command, but offers additional features such as a warning before killing a process.<\/p>\n<pre><code class=\"language-bash line-numbers\">timelimit -t30 -T10 .\/long_running_script.sh\n\n# Output:\n# Runs the long_running_script.sh script, sends a TERM signal after 30 seconds if it is still running, and sends a KILL signal after an additional 10 seconds if it is still running.\n<\/code><\/pre>\n<p>In this example, the &#8216;timelimit&#8217; command runs the script and sends a TERM signal after 30 seconds if the script is still running. If the script does not terminate within an additional 10 seconds, a KILL signal is sent. This allows the process some time to clean up before being forcibly terminated.<\/p>\n<p>While these alternative methods can be useful in certain scenarios, the &#8216;timeout&#8217; command in Linux is a versatile and powerful tool that is well-suited for managing process durations. By understanding and utilizing these various methods, you can effectively manage long-running processes in your Linux system.<\/p>\n<h2>Troubleshooting the Timeout Command: Common Issues and Solutions<\/h2>\n<p>While the &#8216;timeout&#8217; command in Linux is a versatile tool, like any other command, it has its quirks and challenges. In this section, we&#8217;ll discuss some of the common issues you might encounter while using the &#8216;timeout&#8217; command and provide solutions to help you overcome them.<\/p>\n<h3>Issue 1: Command Doesn&#8217;t Stop After Timeout<\/h3>\n<p>Sometimes, you may find that a process doesn&#8217;t stop even after the specified timeout duration. This can happen if the process spawns child processes that continue to run after the parent process is terminated.<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout 5s .\/parent_script.sh\n\n# Output:\n# The parent_script.sh is terminated after 5 seconds, but the child processes spawned by the script continue to run.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command stops the &#8216;parent_script.sh&#8217; script after 5 seconds. However, if the script has spawned child processes, they will continue to run.<\/p>\n<h4>Solution<\/h4>\n<p>To solve this issue, you can use the <code>--kill-after<\/code> option with the &#8216;timeout&#8217; command. This option ensures that all child processes are also terminated after the timeout.<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout --kill-after=5s 5s .\/parent_script.sh\n\n# Output:\n# The parent_script.sh and all its child processes are terminated after 5 seconds.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command with the <code>--kill-after<\/code> option ensures that &#8216;parent_script.sh&#8217; and all its child processes are terminated after 5 seconds.<\/p>\n<h3>Issue 2: Timeout Command Not Found<\/h3>\n<p>On some systems, particularly older or minimal installations, the &#8216;timeout&#8217; command might not be available by default.<\/p>\n<h4>Solution<\/h4>\n<p>If you encounter this issue, you can install the &#8216;timeout&#8217; command using the package manager for your system. On Debian-based systems like Ubuntu, you can use the following command:<\/p>\n<pre><code class=\"language-bash line-numbers\">sudo apt-get install coreutils\n\n# Output:\n# Installs the coreutils package, which includes the 'timeout' command.\n<\/code><\/pre>\n<p>In this example, the &#8216;apt-get install&#8217; command installs the &#8216;coreutils&#8217; package, which includes the &#8216;timeout&#8217; command.<\/p>\n<p>These are just a few of the common issues you might encounter while using the &#8216;timeout&#8217; command in Linux. By understanding these potential pitfalls and their solutions, you can effectively use the &#8216;timeout&#8217; command to manage process durations in your system.<\/p>\n<h2>Understanding Linux Process Management and Signals<\/h2>\n<p>To fully grasp the power and utility of the &#8216;timeout&#8217; command in Linux, it&#8217;s essential to understand some fundamental concepts about process management in Linux and how signals work.<\/p>\n<h3>Linux Process Management<\/h3>\n<p>In Linux, every task, whether it&#8217;s a command executed by a user or system-level task, is treated as a process. Each process has a unique process ID (PID) and is managed by the Linux kernel.<\/p>\n<p>Processes can have various states such as running, sleeping, stopped, or zombie. The Linux kernel schedules these processes, allocates system resources, and ensures smooth execution of tasks.<\/p>\n<h3>Signals in Linux<\/h3>\n<p>Signals are software interrupts that provide a method of handling asynchronous events. They are used in Linux systems to communicate with or control processes.<\/p>\n<p>For example, when you use the <code>Ctrl+C<\/code> command in the terminal, you&#8217;re sending an interrupt signal (SIGINT) to the current process. Similarly, the &#8216;timeout&#8217; command uses signals to terminate a process after a specified duration.<\/p>\n<p>Here&#8217;s an example of sending a signal to a process in Linux:<\/p>\n<pre><code class=\"language-bash line-numbers\">kill -SIGINT 1234\n\n# Output:\n# Sends an interrupt signal to the process with PID 1234.\n<\/code><\/pre>\n<p>In this example, the <code>kill<\/code> command is used to send an interrupt signal (SIGINT) to the process with PID 1234. This will terminate the process, similar to how the &#8216;timeout&#8217; command terminates a process after a specified duration.<\/p>\n<h3>How Does the &#8216;Timeout&#8217; Command Work?<\/h3>\n<p>The &#8216;timeout&#8217; command in Linux leverages the concept of signals to manage process durations. When you run a process with the &#8216;timeout&#8217; command, it starts the process and sets a timer for the specified duration.<\/p>\n<p>When the timer expires, the &#8216;timeout&#8217; command sends a TERM signal to the process. If the process is still running after a certain grace period (default is 10 seconds), a KILL signal is sent to forcibly terminate the process.<\/p>\n<p>Here&#8217;s an example of using the &#8216;timeout&#8217; command with a grace period:<\/p>\n<pre><code class=\"language-bash line-numbers\">timeout -k 5s 30s .\/long_running_script.sh\n\n# Output:\n# Runs the long_running_script.sh script, sends a TERM signal after 30 seconds if it is still running, and sends a KILL signal after an additional 5 seconds if it is still running.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command runs the &#8216;long_running_script.sh&#8217; script and sends a TERM signal after 30 seconds if the script is still running. If the script does not terminate within an additional 5 seconds, a KILL signal is sent. This allows the process some time to clean up before being forcibly terminated.<\/p>\n<p>By understanding these fundamental concepts, you can better appreciate how the &#8216;timeout&#8217; command works and use it more effectively in managing process durations in Linux.<\/p>\n<h2>The Timeout Command in Real-World Applications<\/h2>\n<p>The &#8216;timeout&#8217; command in Linux is not just a theoretical concept or a tool for managing processes in a sandbox environment. It has practical applications in real-world scenarios, particularly in scripting and automation.<\/p>\n<h3>Timeout in Scripting<\/h3>\n<p>In scripting, the &#8216;timeout&#8217; command can be a lifesaver. Scripts often involve tasks that can potentially run indefinitely or for an extended period, consuming significant system resources. By using the &#8216;timeout&#8217; command, you can ensure that your scripts don&#8217;t exceed a certain duration.<\/p>\n<p>Here&#8217;s an example of using the &#8216;timeout&#8217; command in a script:<\/p>\n<pre><code class=\"language-bash line-numbers\">#!\/bin\/bash\n\n# Run a data fetching script with a timeout of 2 minutes\nif timeout 2m .\/fetch_data.sh ; then\n    echo \"Data fetched successfully\"\nelse\n    echo \"Data fetching timed out\"\nfi\n\n# Output:\n# Runs the fetch_data.sh script. If the script completes within 2 minutes, it prints 'Data fetched successfully'. Otherwise, it prints 'Data fetching timed out'.\n<\/code><\/pre>\n<p>In this example, the &#8216;timeout&#8217; command is used in a bash script to run another script, &#8216;fetch_data.sh&#8217;, with a timeout of 2 minutes. If &#8216;fetch_data.sh&#8217; completes within 2 minutes, the script prints &#8216;Data fetched successfully&#8217;. Otherwise, it prints &#8216;Data fetching timed out&#8217;. This can be particularly useful in automation scripts where you want to ensure that tasks complete within a certain timeframe.<\/p>\n<h3>Timeout in Automation<\/h3>\n<p>In automation, the &#8216;timeout&#8217; command can help you manage long-running tasks. For instance, if you have a cron job that runs a script every hour, you can use the &#8216;timeout&#8217; command to ensure that the script doesn&#8217;t run for more than 50 minutes. This way, you can prevent overlapping executions of the script.<\/p>\n<h3>Related Commands and Topics for Further Exploration<\/h3>\n<p>The &#8216;timeout&#8217; command is part of a larger ecosystem of commands and tools for process management in Linux. If you&#8217;re interested in diving deeper, here are a few related commands and topics you might find interesting:<\/p>\n<ul>\n<li>The &#8216;kill&#8217; command: Used to send signals to processes.<\/li>\n<li>The &#8216;ps&#8217; command: Used to list and manage running processes.<\/li>\n<li>The &#8216;top&#8217; command: Used to monitor system, process, and task performance.<\/li>\n<\/ul>\n<h3>Further Resources for Mastering Linux Process Management<\/h3>\n<p>If you&#8217;re interested in learning more about the &#8216;timeout&#8217; command and process management in Linux, here are a few resources you might find useful:<\/p>\n<ol>\n<li><a class=\"wp-editor-md-post-content-link\" href=\"https:\/\/www.gnu.org\/software\/coreutils\/manual\/html_node\/timeout-invocation.html\" target=\"_blank\" rel=\"noopener\">GNU Coreutils: timeout invocation<\/a>: The official documentation for the &#8216;timeout&#8217; command from GNU Coreutils.<\/p>\n<\/li>\n<li>\n<p><a class=\"wp-editor-md-post-content-link\" href=\"https:\/\/itsfoss.community\/t\/how-do-i-start-kill-a-process-at-a-given-time-of-day\/9105\" target=\"_blank\" rel=\"noopener\">How Do I Start\/Kill a Process at a Given Time of Day?<\/a>: It&#8217;s FOSS Community, this forum post on provides guidance on how to schedule the start or termination of a process at a specific time of day in Linux.<\/p>\n<\/li>\n<li>\n<p><a class=\"wp-editor-md-post-content-link\" href=\"https:\/\/www.linuxjournal.com\/article\/3985\" target=\"_blank\" rel=\"noopener\">Understanding Linux signals<\/a>: A comprehensive article on Linux Journal about understanding and working with signals in Linux.<\/p>\n<\/li>\n<\/ol>\n<h2>Recap: Mastering the Timeout Command in Linux<\/h2>\n<p>In this comprehensive guide, we&#8217;ve delved deep into the world of the &#8216;timeout&#8217; command in Linux, a powerful tool for managing process durations. We&#8217;ve explored its basic usage, advanced features, and common issues, providing you with solutions to help you effectively manage long-running processes in your Linux system.<\/p>\n<p>We started with the basics, learning how to use the &#8216;timeout&#8217; command to terminate a process after a certain period of time. We then delved into the advanced usage of &#8216;timeout&#8217;, exploring how to specify time in different units, send a specific signal after timeout, and more. We also tackled common issues you might encounter while using the &#8216;timeout&#8217; command, such as the command not stopping after timeout or the command not being found, providing solutions for each issue.<\/p>\n<p>In addition to the &#8216;timeout&#8217; command, we explored alternative methods to achieve process timeout in Linux, such as using the &#8216;kill&#8217; command with &#8216;sleep&#8217;, and third-party tools like &#8216;Timelimit&#8217;.<\/p>\n<table>\n<thead>\n<tr>\n<th>Method<\/th>\n<th>Pros<\/th>\n<th>Cons<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Timeout Command<\/td>\n<td>Flexible, powerful<\/td>\n<td>Might require troubleshooting for some processes<\/td>\n<\/tr>\n<tr>\n<td>Kill Command with Sleep<\/td>\n<td>Simple, easy to use<\/td>\n<td>Less precise than &#8216;timeout&#8217;<\/td>\n<\/tr>\n<tr>\n<td>Third-Party Tools<\/td>\n<td>Additional features<\/td>\n<td>Requires installation<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Whether you&#8217;re just starting out with the &#8216;timeout&#8217; command or you&#8217;re looking to level up your Linux process management skills, we hope this guide has given you a deeper understanding of the &#8216;timeout&#8217; command and its capabilities.<\/p>\n<p>With the &#8216;timeout&#8217; command in your Linux toolkit, you&#8217;re well equipped to manage process durations effectively. Happy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Are you finding it challenging to manage long-running processes in Linux? You&#8217;re not alone. Many system administrators and developers grapple with this task, but there&#8217;s a tool that can make this process a breeze. Like a vigilant supervisor, the &#8216;timeout&#8217; command in Linux is a handy utility that can seamlessly control processes that run longer [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":14233,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[124,3,9],"tags":[],"class_list":["post-6505","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bash","category-linux","category-sysadmin","cat-124-id","cat-3-id","cat-9-id","has_thumb"],"_links":{"self":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6505","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/comments?post=6505"}],"version-history":[{"count":7,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6505\/revisions"}],"predecessor-version":[{"id":14237,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6505\/revisions\/14237"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media\/14233"}],"wp:attachment":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media?parent=6505"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/categories?post=6505"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/tags?post=6505"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}