{"id":18171,"date":"2026-09-22T05:53:33","date_gmt":"2026-09-22T05:53:33","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18171"},"modified":"2026-09-22T05:53:33","modified_gmt":"2026-09-22T05:53:33","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part5-q81-100","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part5-q81-100\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part5 Q81-100"},"content":{"rendered":"

View Full <\/b>Cisco CCNP Automation 350-901 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Q81. A Python network automation script makes an HTTPS request to a controller. The request should fail rather than wait indefinitely if the controller becomes unresponsive. Which implementation is most appropriate?<\/b><\/p>\n

    \n
  1. <\/b> Remove all exception handling<\/span>
    \n<\/span>2.<\/b> Configure an explicit request timeout<\/span>
    \n<\/span>3.<\/b> Retry continuously without delay<\/span>
    \n<\/span>4.<\/b> Disable TLS certificate validation<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Configure an explicit request timeout<\/b><\/p>\n

    Explanation:<\/b> Network automation code should define explicit timeouts for external API calls so the application does not wait indefinitely when a controller, device, or network path stops responding. The script can catch the resulting timeout exception and decide whether the condition is retryable or should terminate the workflow. Unlimited waits can cause pipelines and orchestration jobs to remain stuck for long periods. Disabling certificate validation does not solve availability problems and weakens transport security. Good API consumers combine sensible timeout values with exception handling, bounded retries, backoff, logging, and clear failure behavior.<\/span><\/p>\n

    Q82. An Ansible task saves the output of a device command so that a later task can evaluate it. Which Ansible keyword should be used?<\/b><\/p>\n

      \n
    1. <\/b> register<\/span>
      \n<\/span>2.<\/b> notify<\/span>
      \n<\/span>3.<\/b> become<\/span>
      \n<\/span>4.<\/b> serial<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. <\/b>register<\/b><\/p>\n

      Explanation:<\/b> The <\/span>register<\/span> keyword stores the result returned by an Ansible task in a variable. Later tasks can inspect fields within that result and make conditional decisions, generate reports, or perform validation. For example, output from a network command can be registered and then evaluated with a <\/span>when<\/span> condition. <\/span>notify<\/span> triggers a handler after a task reports a change, <\/span>become<\/span> relates to privilege escalation on supported hosts, and <\/span>serial<\/span> controls batch size during play execution. Registering task results is useful when automation must make decisions based on observed network state.<\/span><\/p>\n

      Q83. A Terraform configuration needs a subnet value that differs between development and production environments. Which Terraform construct is most appropriate for supplying this value without duplicating the resource configuration?<\/b><\/p>\n

        \n
      1. <\/b> Provider alias only<\/span>
        \n<\/span>2.<\/b> State lock<\/span>
        \n<\/span>3.<\/b> Input variable<\/span>
        \n<\/span>4.<\/b> Output value only<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Input variable<\/b><\/p>\n

        Explanation:<\/b> Terraform input variables allow reusable configuration to accept environment-specific values such as IP prefixes, VLAN IDs, site names, device addresses, or credentials references. The same module or resource configuration can therefore be used across development, test, and production while each environment supplies its own values. Output values expose selected information after evaluation rather than primarily providing input. State locking protects concurrent state modification, and provider aliases help manage multiple provider configurations. Variables improve reuse and reduce duplicated infrastructure code, which makes automation easier to maintain and review.<\/span><\/p>\n

        Q84. A RESTCONF client must completely replace the representation of an existing configuration resource with a supplied representation. Which HTTP method is most appropriate?<\/b><\/p>\n

          \n
        1. <\/b> GET<\/span>
          \n<\/span>2.<\/b> HEAD<\/span>
          \n<\/span>3.<\/b> PATCH<\/span>
          \n<\/span>4.<\/b> PUT<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4. PUT<\/b><\/p>\n

          Explanation:<\/b> HTTP PUT is commonly used to create or completely replace the representation of a resource at a specified URI. In RESTCONF, the exact behavior must comply with RFC 8040 and the target platform’s implementation, but PUT is appropriate when the client intends to replace the addressed configuration data rather than make only a partial modification. PATCH is generally better suited to partial updates. GET retrieves data, while HEAD retrieves metadata without the normal response body. Automation engineers should understand the difference because choosing the wrong method can unintentionally replace more configuration than intended.<\/span><\/p>\n

          Q85. A Python script must process a large list of devices one at a time while avoiding unnecessary creation of a second complete list in memory. Which Python approach is most appropriate?<\/b><\/p>\n

            \n
          1. <\/b> Iterate over the existing collection or generator directly<\/span>
            \n<\/span>2.<\/b> Copy the device list repeatedly before each operation<\/span>
            \n<\/span>3.<\/b> Serialize every item to a separate database first<\/span>
            \n<\/span>4.<\/b> Convert every item to an image<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Iterate over the existing collection or generator directly<\/b><\/p>\n

            Explanation:<\/b> Iterating directly over an existing collection avoids unnecessary copies and keeps automation code simple. When data can be produced lazily, a generator can be even more memory efficient because items are created as needed rather than all at once. This can matter when automation processes very large inventories or API datasets. Repeatedly copying lists consumes additional memory and CPU without improving the workflow. Network automation code should be designed for predictable resource use because inventory size can grow substantially as automation is expanded from a few devices to enterprise-scale environments.<\/span><\/p>\n

            Q86. A Git repository contains a local change to a tracked file that has not yet been committed. The engineer wants to discard that working-tree modification and restore the file from the current branch. Which command is appropriate?<\/b><\/p>\n

              \n
            1. <\/b> git cherry-pick<\/span>
              \n<\/span>2.<\/b> git checkout — <file><\/span> or the modern equivalent <\/span>git restore <file><\/span>
              \n<\/span>3.<\/b> git merge<\/span>
              \n<\/span>4.<\/b> git init<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. <\/b>git checkout — <file><\/b> or the modern equivalent <\/b>git restore <file><\/b><\/p>\n

              Explanation:<\/b> git checkout — <file><\/span> restores a tracked file in the working tree from the current index or commit, while modern Git also provides <\/span>git restore<\/span> for this purpose. This is appropriate when an engineer wants to discard local uncommitted modifications. Because the action can destroy local work, it should be used carefully. <\/span>git cherry-pick<\/span> applies a selected commit, <\/span>git merge<\/span> combines histories, and <\/span>git init<\/span> creates a new repository. Understanding checkout and restore behavior is important when maintaining infrastructure code and automation repositories safely.<\/span><\/p>\n

              Q87. A GitLab pipeline should stop before production deployment if network prevalidation tests fail. Which pipeline behavior is most appropriate?<\/b><\/p>\n

                \n
              1. <\/b> Ignore the test result<\/span>
                \n<\/span>2.<\/b> Continue deployment but hide the failure<\/span>
                \n<\/span>3.<\/b> Delete the validation stage<\/span>
                \n<\/span>4.<\/b> Mark the prevalidation job as a required dependency that must succeed<\/span><\/li>\n<\/ol>\n

                Correct Answer: 4. Mark the prevalidation job as a required dependency that must succeed<\/b><\/p>\n

                Explanation:<\/b> A safe CI\/CD pipeline should prevent deployment when required prevalidation checks fail. The deploy stage can depend on the successful completion of prevalidation jobs so the pipeline stops automatically when prerequisites are not met. This protects production infrastructure from changes made under unexpected network conditions. Hiding or ignoring failures defeats the purpose of validation. Cisco’s current AUTOCOR blueprint explicitly includes build, prevalidation, deploy, and post-validation stages, so understanding how pipeline control flow enforces these gates is important for safe network automation.<\/span><\/p>\n

                Q88. An automation engineer wants to test a routing change against a topology that closely mirrors production but does not affect real users. What is the best use of Cisco Modeling Labs?<\/b><\/p>\n

                  \n
                1. <\/b> Store Git credentials<\/span>
                  \n<\/span>2.<\/b> Replace the source of truth<\/span>
                  \n<\/span>3.<\/b> Build a simulation or digital twin for pre-deployment testing<\/span>
                  \n<\/span>4.<\/b> Act as a CA for production certificates<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Build a simulation or digital twin for pre-deployment testing<\/b><\/p>\n

                  Explanation:<\/b> Cisco Modeling Labs can provide simulated Cisco network topologies that reproduce relevant aspects of production behavior. Engineers can apply proposed automation, observe routing convergence, run validation, and test failure scenarios before deploying to real infrastructure. This reduces operational risk and can be integrated into CI\/CD pipelines. A simulation should still be validated against actual production differences such as software versions, scale, and physical dependencies. Cisco’s AUTOCOR training explicitly includes building CML topologies and integrating them with automated pipelines.<\/span><\/p>\n

                  Q89. A YANG model defines a leaf as type <\/b>boolean<\/b>. Which JSON value correctly represents the enabled state?<\/b><\/p>\n

                    \n
                  1. <\/b> “enabled”<\/span>
                    \n<\/span>2.<\/b> true<\/span>
                    \n<\/span>3.<\/b> “yes”<\/span>
                    \n<\/span>4.<\/b> 1<\/span> as a quoted string<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2. <\/b>true<\/b><\/p>\n

                    Explanation:<\/b> JSON provides native Boolean values <\/span>true<\/span> and <\/span>false<\/span>, and a YANG Boolean leaf maps naturally to those JSON Boolean types when encoded according to the applicable model-driven interface rules. Using arbitrary strings such as <\/span>“enabled”<\/span> or <\/span>“yes”<\/span> does not preserve the data type expected by the model. The automation client should always follow the YANG schema rather than guessing value formats. Strongly modeled data is one advantage of RESTCONF and NETCONF because automation can validate structure and data types more reliably than when parsing free-form CLI text.<\/span><\/p>\n

                    Q90. A network controller API returns a <\/b>Retry-After<\/b> header with an HTTP 429 response. What should the automation client do?<\/b><\/p>\n

                      \n
                    1. <\/b> Delete the requested resource<\/span>
                      \n<\/span>2.<\/b> Ignore the header<\/span>
                      \n<\/span>3.<\/b> Reauthenticate continuously<\/span>
                      \n<\/span>4.<\/b> Delay the next retry according to the server-provided guidance<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 4. Delay the next retry according to the server-provided guidance<\/b><\/p>\n

                      Explanation:<\/b> HTTP 429 means the client has exceeded the service’s rate limit. When the server includes a <\/span>Retry-After<\/span> header, the client should respect that guidance before attempting another request. Doing so reduces unnecessary load and improves the chance that later requests will succeed. The automation should also bound the number of retries and log repeated throttling conditions. Ignoring the server’s retry guidance can produce a retry storm and extend throttling. Reliable network automation must account for API rate limits because controller platforms often protect themselves from excessive request volume.<\/span><\/p>\n

                      Q91. An automation solution uses NetBox as its source of truth. What is the safest behavior when the source of truth lists an interface as disabled but the live device reports it enabled?<\/b><\/p>\n

                        \n
                      1. <\/b> Compare the discrepancy with policy and determine whether controlled remediation is authorized<\/span>
                        \n<\/span>2.<\/b> Always trust the live device and overwrite NetBox immediately<\/span>
                        \n<\/span>3.<\/b> Always shut the interface regardless of context<\/span>
                        \n<\/span>4.<\/b> Ignore the mismatch permanently<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. Compare the discrepancy with policy and determine whether controlled remediation is authorized<\/b><\/p>\n

                        Explanation:<\/b> A difference between authoritative intended state and live device state is configuration drift, but automation should not automatically assume which side is wrong. The source of truth may be stale, or the device may have been changed outside the approved process. A safe workflow identifies the discrepancy, validates intended state, checks change records or policy, and then performs controlled reconciliation if authorized. Blindly overwriting the source of truth can legitimize unauthorized changes, while blindly shutting an interface can create an outage. Source-of-truth integration requires governance as well as technical automation.<\/span><\/p>\n

                        Q92. A Docker Compose file defines <\/b>depends_on<\/b> between two services. What does this primarily express?<\/b><\/p>\n

                          \n
                        1. <\/b> The dependent service must use the same container image<\/span>
                          \n<\/span>2.<\/b> A service startup dependency relationship between the defined services<\/span>
                          \n<\/span>3.<\/b> Both services must expose identical ports<\/span>
                          \n<\/span>4.<\/b> The services must use the same volume<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. A service startup dependency relationship between the defined services<\/b><\/p>\n

                          Explanation:<\/b> In Docker Compose, <\/span>depends_on<\/span> expresses a dependency in the service startup ordering. It can help ensure that one service is started before another. Engineers should not assume basic <\/span>depends_on<\/span> alone guarantees that the dependency is fully ready to serve traffic; health checks and appropriate application retry behavior may still be necessary. The directive does not require services to use identical images, ports, or volumes. AUTOCOR includes interpreting Compose files containing services, networks, volumes, and links or dependencies, making these relationships important for containerized automation components.<\/span><\/p>\n

                          Q93. An automation script sends event information to Syslog. What field is most useful for quickly distinguishing informational events from errors?<\/b><\/p>\n

                            \n
                          1. <\/b> Severity level<\/span>
                            \n<\/span>2.<\/b> Device screen resolution<\/span>
                            \n<\/span>3.<\/b> Git branch name only<\/span>
                            \n<\/span>4.<\/b> Terraform provider checksum only<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Severity level<\/b><\/p>\n

                            Explanation:<\/b> Syslog severity indicates the importance of an event, ranging from emergencies through debugging-level messages. Appropriate severity classification helps collectors, SIEM systems, dashboards, and operators prioritize events and define alerting behavior. A failed device configuration operation should not be logged at the same severity as routine debug output. Good logging should also include timestamps, device or application identity, job identifiers, and useful contextual information. AUTOCOR expects candidates to implement logging strategies using files, Syslog, and webhooks, so understanding useful log attributes is important for operational automation.<\/span><\/p>\n

                            Q94. A Python script catches an exception but uses only <\/b>pass<\/b>, causing the workflow to continue silently. What is the main risk?<\/b><\/p>\n

                              \n
                            1. <\/b> The script becomes more observable<\/span>
                              \n<\/span>2.<\/b> Failures can be hidden and later operations may run with invalid assumptions<\/span>
                              \n<\/span>3.<\/b> API authentication becomes stronger<\/span>
                              \n<\/span>4.<\/b> Terraform state is automatically repaired<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. Failures can be hidden and later operations may run with invalid assumptions<\/b><\/p>\n

                              Explanation:<\/b> Silently swallowing exceptions can cause automation to continue after an important operation failed. Later tasks may act on incomplete data, missing configuration, or incorrect state and can therefore make the original problem more difficult to diagnose. Exceptions should be handled intentionally: recover when the condition is understood and safe, or log meaningful context and fail clearly when continuation would be dangerous. Robust automation favors explicit error handling over broad <\/span>except<\/span> blocks that hide failures. Operational logs should also avoid exposing secrets while still providing enough context for troubleshooting.<\/span><\/p>\n

                              Q95. An engineer needs a CA-signed certificate for a new internal automation service. Which item is sent to the certificate authority for signing?<\/b><\/p>\n

                                \n
                              1. <\/b> The server’s private key<\/span>
                                \n<\/span>2.<\/b> The Git repository<\/span>
                                \n<\/span>3.<\/b> The certificate signing request<\/span>
                                \n<\/span>4.<\/b> The Terraform state file<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3. The certificate signing request<\/b><\/p>\n

                                Explanation:<\/b> A certificate signing request, or CSR, contains the public key and identity information the certificate authority uses when issuing the certificate. The corresponding private key should remain protected on the system or key-management infrastructure and should never be sent to the CA as part of a normal signing process. After validation, the CA signs the request and returns a certificate that can be installed together with the appropriate chain. Cisco’s AUTOCOR Operations domain explicitly includes obtaining and deploying CA-signed TLS certificates, so candidates should understand this certificate lifecycle.<\/span><\/p>\n

                                Q96. A generative AI system produces a Python automation script using a nonexistent library method. Which AI behavior does this illustrate?<\/b><\/p>\n

                                  \n
                                1. <\/b> Deterministic compilation<\/span>
                                  \n<\/span>2.<\/b> State locking<\/span>
                                  \n<\/span>3.<\/b> Idempotency<\/span>
                                  \n<\/span>4.<\/b> Hallucination<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 4. Hallucination<\/b><\/p>\n

                                  Explanation:<\/b> Generative AI can produce plausible-looking but incorrect code, commands, APIs, or library methods. This is commonly called hallucination. Network automation engineers must therefore validate generated code against authoritative documentation, lint and test it, and run it in controlled environments before production use. AI-generated automation can accelerate development but should be treated as untrusted output until verified. Cisco’s AUTOCOR blueprint explicitly includes understanding the benefits and risks of generative AI in network automation, including the need for code validation.<\/span><\/p>\n

                                  Q97. An AI agent retrieves current interface state through an MCP server. Which design most reduces the chance that the agent can accidentally modify configuration?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Expose only read-only tools through the MCP server for this use case<\/span>
                                    \n<\/span>2.<\/b> Give the AI full configuration privileges<\/span>
                                    \n<\/span>3.<\/b> Let any prompt execute arbitrary shell commands<\/span>
                                    \n<\/span>4.<\/b> Disable tool-call logging<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 2. Expose only read-only tools through the MCP server for this use case<\/b><\/p>\n

                                    Explanation:<\/b> If the agent’s purpose is to answer questions about network state, its MCP tools should expose only the read operations required. This creates a technical least-privilege boundary independent of what the language model requests. Even if a user attempts prompt injection or the model makes an error, unavailable write functions cannot be called through that interface. Authentication, parameter validation, and logging should also be implemented. Cisco’s AUTOCOR AI domain includes building FastMCP servers to provide network information to agents, making secure tool design an important consideration.<\/span><\/p>\n

                                    Q98. An engineer asks an AI assistant to recommend an ACL change. The suggestion blocks a critical monitoring system. What should the workflow do?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Apply the ACL because AI-generated output is authoritative<\/span>
                                      \n<\/span>2.<\/b> Validate the recommendation against requirements and simulation or test results before deployment<\/span>
                                      \n<\/span>3.<\/b> Delete monitoring from the design<\/span>
                                      \n<\/span>4.<\/b> Remove post-validation from the pipeline<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 3. Validate the recommendation against requirements and simulation or test results before deployment<\/b><\/p>\n

                                      Explanation:<\/b> AI recommendations can be incorrect or incomplete, so they must be validated against authoritative requirements and expected network behavior. A CML simulation, policy checks, prevalidation, or human review can reveal that the proposed ACL blocks legitimate monitoring traffic. Only validated recommendations should progress to production. High-impact network changes may also require approval and rollback mechanisms. Cisco’s current AUTOCOR exam explicitly tests evaluation of AI recommendation accuracy. AI should therefore assist network engineering rather than replace deterministic validation and change-control safeguards.<\/span><\/p>\n

                                      Q99. A conversational AI agent answers questions using stale interface information cached from the previous week. What architectural improvement is most appropriate?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Integrate the agent with a controlled source of current network state<\/span>
                                        \n<\/span>2.<\/b> Tell users to assume all answers are current<\/span>
                                        \n<\/span>3.<\/b> Disable timestamps<\/span>
                                        \n<\/span>4.<\/b> Remove network data access entirely while still claiming real-time answers<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. Integrate the agent with a controlled source of current network state<\/b><\/p>\n

                                        Explanation:<\/b> Operational questions require timely information. An LLM relying only on stale cached data can produce answers that are linguistically convincing but operationally incorrect. A controlled tool or MCP server can query an authoritative source, controller, telemetry platform, or network device when current state is needed. The agent should identify the data source and timestamp where useful. Authorization and validation must still apply to the retrieval operation. Cisco’s AUTOCOR AI objectives include constructing conversational agents connected to network information, which requires thinking carefully about data freshness as well as natural-language capabilities.<\/span><\/p>\n

                                        Q100. An AI agent can perform both read and write operations. Which workflow is best for a destructive configuration action such as deleting a VLAN used in production?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Execute it immediately whenever the model suggests it<\/span>
                                          \n<\/span>2.<\/b> Disable authorization before deletion<\/span>
                                          \n<\/span>3.<\/b> Require validation and an explicit approval step before the destructive tool call<\/span>
                                          \n<\/span>4.<\/b> Delete audit records afterward<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. Require validation and an explicit approval step before the destructive tool call<\/b><\/p>\n

                                          Explanation:<\/b> Destructive infrastructure actions deserve stronger safeguards than ordinary read operations. The workflow should validate the target and business intent, check authoritative state, assess dependencies, and require an explicit approval or other policy gate before execution. The tool identity should also have narrowly scoped permissions and all actions should be logged. Relying solely on an LLM’s decision can amplify hallucinations or prompt injection into real outages. Safe AI network automation separates conversational reasoning from deterministic authorization and change-control mechanisms.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q81. A Python network automation script makes an HTTPS request to a controller. The request should fail rather than wait indefinitely if the controller becomes unresponsive. Which implementation is most appropriate? Remove all exception handling 2. Configure an explicit request timeout 3. Retry […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18171"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=18171"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18171\/revisions"}],"predecessor-version":[{"id":18172,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18171\/revisions\/18172"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18171"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18171"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18171"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}