{"id":18189,"date":"2026-09-22T05:58:58","date_gmt":"2026-09-22T05:58:58","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18189"},"modified":"2026-09-22T05:58:58","modified_gmt":"2026-09-22T05:58:58","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part14-q261-280","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part14-q261-280\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part14 Q261-280"},"content":{"rendered":"

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


\n<\/b>Q261. An Ansible play targets 50 routers, but an API request must originate from the automation controller rather than from each router. Which Ansible keyword is most appropriate for running that task on the controller?<\/b><\/p>\n

    \n
  1. <\/b> run_once<\/span>
    \n<\/span>2.<\/b> delegate_to: localhost<\/span>
    \n<\/span>3.<\/b> serial<\/span>
    \n<\/span>4.<\/b> notify<\/span><\/li>\n<\/ol>\n

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

    Explanation:<\/b> delegate_to<\/span> allows an Ansible task to execute on a host other than the inventory host currently being processed. Using <\/span>delegate_to: localhost<\/span> is useful when the automation controller must call an external API, update a ticketing system, or perform another controller-side operation while the play still targets network devices. <\/span>run_once<\/span> controls how many times a task executes but does not determine where it runs. <\/span>serial<\/span> defines host batching, while <\/span>notify<\/span> triggers handlers. Delegation makes workflows more flexible by allowing device-oriented plays to interact safely with centralized services from the appropriate execution location.<\/span><\/p>\n

    Q262. A Terraform-managed network object is healthy, but an engineer wants Terraform to replace it during the next apply without manually deleting it first. Which mechanism is most appropriate?<\/b><\/p>\n

      \n
    1. <\/b> Remove the provider block<\/span>
      \n<\/span>2.<\/b> Delete the state file<\/span>
      \n<\/span>3.<\/b> Set every variable to <\/span>null<\/span>
      \n<\/span>4.<\/b> Request resource replacement using Terraform’s replace mechanism during planning or apply<\/span><\/li>\n<\/ol>\n

      Correct Answer: 4. Request resource replacement using Terraform’s replace mechanism during planning or apply<\/b><\/p>\n

      Explanation:<\/b> Terraform supports explicitly requesting replacement of a managed resource when an operator needs the object recreated even though its configuration may not otherwise require replacement. Modern Terraform workflows can use a replace option during planning or apply rather than manually deleting infrastructure or corrupting state. This keeps the replacement operation visible in the execution plan and preserves Terraform’s understanding of the resource lifecycle. Deleting state can cause Terraform to lose resource tracking, while removing provider configuration prevents normal management. Planned replacement is therefore safer and more auditable than ad hoc infrastructure deletion.<\/span><\/p>\n

      Q263. A RESTCONF client retrieves a resource but wants the server to return only configuration data, excluding operational state where the platform supports such filtering. What should the client use?<\/b><\/p>\n

        \n
      1. <\/b> An appropriate RESTCONF content-filtering query parameter<\/span>
        \n<\/span>2.<\/b> HTTP DELETE<\/span>
        \n<\/span>3.<\/b> A Git branch filter<\/span>
        \n<\/span>4.<\/b> A Terraform output block<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. An appropriate RESTCONF content-filtering query parameter<\/b><\/p>\n

        Explanation:<\/b> RESTCONF supports query parameters that can influence which categories of modeled data are returned, depending on the request and server implementation. A client may request configuration-oriented content rather than retrieving every available operational field. Reducing unnecessary data improves response efficiency, parsing time, and clarity for the automation workflow. Engineers should verify platform support and construct the request according to RFC 8040 and the applicable YANG model. DELETE changes resources and is unrelated to response filtering. Git and Terraform constructs likewise have no role in selecting RESTCONF response content.<\/span><\/p>\n

        Q264. A Python automation project passes structured device information among many functions. The team wants a lightweight class mainly for storing fields such as hostname, management IP, and platform. Which Python feature is well suited to this purpose?<\/b><\/p>\n

          \n
        1. <\/b> A recursive generator only<\/span>
          \n<\/span>2.<\/b> A raw byte array<\/span>
          \n<\/span>3.<\/b> A data class<\/span>
          \n<\/span>4.<\/b> A shell script embedded in Python<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. A data class<\/b><\/p>\n

          Explanation:<\/b> Python data classes provide a convenient way to define classes whose main purpose is storing structured data. Using the <\/span>dataclasses<\/span> module, engineers can define fields such as hostname, management address, platform, or role while automatically receiving useful methods such as initialization and representation. This can make automation code easier to understand than passing loosely structured dictionaries everywhere. Dictionaries remain appropriate in many cases, especially for dynamic API data, but data classes can improve type clarity and maintainability when the structure is well defined. They do not replace input validation or schema checks.<\/span><\/p>\n

          Q265. A developer wants to download new commits and remote branch references from a Git server without automatically merging them into the current local branch. Which Git command is most appropriate?<\/b><\/p>\n

            \n
          1. <\/b> git fetch<\/span>
            \n<\/span>2.<\/b> git pull<\/span>
            \n<\/span>3.<\/b> git revert<\/span>
            \n<\/span>4.<\/b> git clean<\/span><\/li>\n<\/ol>\n

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

            Explanation:<\/b> git fetch<\/span> retrieves updated commits, branch references, and related objects from a remote repository without automatically integrating them into the current branch. This allows an engineer to inspect remote changes before deciding whether to merge, rebase, or otherwise incorporate them. By contrast, <\/span>git pull<\/span> normally fetches and then performs an integration step according to configuration. In Infrastructure as Code repositories, separating retrieval from integration can be useful when engineers want to review network automation changes carefully before altering the working branch. <\/span>git revert<\/span> reverses commits, while <\/span>git clean<\/span> removes untracked files.<\/span><\/p>\n

            Q266. A GitLab project requires two reviewers to approve changes to production network automation before merging into the protected main branch. Which feature best supports this workflow?<\/b><\/p>\n

              \n
            1. <\/b> Unprotected direct pushes<\/span>
              \n<\/span>2.<\/b> Local Git stashes<\/span>
              \n<\/span>3.<\/b> Merge request approval rules<\/span>
              \n<\/span>4.<\/b> Disabling branch protection<\/span><\/li>\n<\/ol>\n

              Correct Answer: 3. Merge request approval rules<\/b><\/p>\n

              Explanation:<\/b> Merge request approval rules can require designated reviewers or a minimum number of approvals before changes are merged into important branches. Combined with protected branches and required CI checks, this creates a controlled path for network automation changes entering production. Peer review can identify unsafe logic, scope errors, credential exposure, or design problems before they reach deployment stages. Local Git operations such as stash do not enforce organizational review requirements. Strong repository governance is important for Infrastructure as Code because changing a few lines in version control may ultimately affect hundreds or thousands of network devices.<\/span><\/p>\n

              Q267. A GitLab CI pipeline has a post-validation job that must run after deployment and should receive deployment artifacts from an earlier job. What should the pipeline define?<\/b><\/p>\n

                \n
              1. <\/b> A separate unrelated repository<\/span>
                \n<\/span>2.<\/b> A dependency relationship and appropriate artifacts between the jobs<\/span>
                \n<\/span>3.<\/b> A manual router reboot before every test<\/span>
                \n<\/span>4.<\/b> A new Git history for each stage<\/span><\/li>\n<\/ol>\n

                Correct Answer: 4. A dependency relationship and appropriate artifacts between the jobs<\/b><\/p>\n

                Explanation:<\/b> CI\/CD stages should make dependencies explicit so a later validation job receives exactly the files or metadata created by the deployment workflow. Artifacts can carry configuration plans, device lists, test inputs, or deployment results between jobs. Job dependencies or stage ordering ensure post-validation runs at the correct point in the pipeline. This makes the workflow reproducible and easier to troubleshoot. Cisco’s AUTOCOR blueprint explicitly includes build, prevalidation, deploy, and post-validation stages, so candidates should understand how pipeline structure coordinates outputs and execution order across those stages.<\/span><\/p>\n

                Q268. An engineer builds a CML topology to test BGP automation. Why should the virtual node software versions be chosen to resemble production as closely as practical?<\/b><\/p>\n

                  \n
                1. <\/b> To guarantee production and simulation are physically identical<\/span>
                  \n<\/span>2.<\/b> To eliminate all need for production testing<\/span>
                  \n<\/span>3.<\/b> To make Git commits smaller<\/span>
                  \n<\/span>4.<\/b> To reduce behavioral differences caused by platform or software-version mismatches<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2. To reduce behavioral differences caused by platform or software-version mismatches<\/b><\/p>\n

                  Explanation:<\/b> Network operating system versions can differ in command syntax, API behavior, YANG models, defaults, and protocol implementation details. A CML test environment that closely resembles production provides more meaningful results than one using significantly different software. It cannot perfectly reproduce physical hardware, scale, or all external dependencies, so production prevalidation and post-validation remain necessary. The objective is to reduce avoidable differences so automation defects are more likely to be discovered before deployment. Cisco’s AUTOCOR training specifically includes Cisco Modeling Labs as a test environment for network automation.<\/span><\/p>\n

                  Q269. A telemetry system must preserve individual raw measurements for seven days but only hourly summaries for one year. What design concept does this represent?<\/b><\/p>\n

                    \n
                  1. <\/b> Git history rewriting<\/span>
                    \n<\/span>2.<\/b> Certificate renewal<\/span>
                    \n<\/span>3.<\/b> Tiered telemetry retention and aggregation<\/span>
                    \n<\/span>4.<\/b> RESTCONF authentication<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 3. Tiered telemetry retention and aggregation<\/b><\/p>\n

                    Explanation:<\/b> Telemetry platforms often retain high-resolution raw data for a relatively short period while storing aggregated summaries for much longer periods. This balances troubleshooting value against storage cost and query performance. Recent raw data can support detailed incident analysis, while hourly or daily summaries remain useful for capacity trends and long-term reporting. Retention periods should be based on operational, regulatory, and business requirements. Keeping every high-frequency sample indefinitely can become expensive, while overly aggressive deletion can remove useful evidence. AUTOCOR includes telemetry data consumption and storage considerations within its Operations domain.<\/span><\/p>\n

                    Q270. An automation service writes a large local log file that eventually fills the server disk. Which operational control best addresses this problem?<\/b><\/p>\n

                      \n
                    1. <\/b> Log rotation with size or time limits and defined retention<\/span>
                      \n<\/span>2.<\/b> Disable all logging permanently<\/span>
                      \n<\/span>3.<\/b> Store API passwords in the log to make it useful<\/span>
                      \n<\/span>4.<\/b> Create an unlimited number of duplicate logs<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. Log rotation with size or time limits and defined retention<\/b><\/p>\n

                      Explanation:<\/b> Log rotation prevents local log files from growing without bound. Files can be rotated according to size or time, compressed, retained for a defined period, and eventually deleted or archived. Centralized log forwarding can provide additional durability and search capability. Logging should preserve enough information for troubleshooting without exhausting storage or exposing sensitive credentials. Disabling logs makes investigation difficult, while unlimited retention on local disks can create outages when storage is exhausted. A production automation architecture should define both logging content and logging lifecycle, including retention, rotation, transport, and access control.<\/span><\/p>\n

                      Q271. A pyATS test suite should stop running dependent validation sections when a critical setup check proves that the target device is unreachable. What is the main reason for this behavior?<\/b><\/p>\n

                        \n
                      1. <\/b> To produce more false-positive results<\/span>
                        \n<\/span>2.<\/b> To convert test failures into warnings automatically<\/span>
                        \n<\/span>3.<\/b> To remove the testbed file<\/span>
                        \n<\/span>4.<\/b> To avoid running tests whose prerequisites are not satisfied<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 4. To avoid running tests whose prerequisites are not satisfied<\/b><\/p>\n

                        Explanation:<\/b> Validation tests should reflect dependencies among test stages. If a critical setup step shows the device cannot be reached, later tests requiring live device data cannot produce meaningful results. Skipping or blocking those dependent sections avoids misleading secondary failures and makes the root cause clearer to operators. Good test design separates prerequisite failures from actual functional validation failures. This makes automated pipeline results easier to interpret and reduces troubleshooting noise. pyATS is included in Cisco’s AUTOCOR training specifically for configuration and operational validation of automation workflows.<\/span><\/p>\n

                        Q272. A Dockerized automation application repeatedly creates temporary files. The files should disappear whenever the container is replaced and do not need persistence. Where should they generally be stored?<\/b><\/p>\n

                          \n
                        1. <\/b> In the application’s external production database<\/span>
                          \n<\/span>2.<\/b> In ephemeral container storage or another temporary filesystem<\/span>
                          \n<\/span>3.<\/b> In a permanent shared volume by default<\/span>
                          \n<\/span>4.<\/b> In the Git repository<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. In ephemeral container storage or another temporary filesystem<\/b><\/p>\n

                          Explanation:<\/b> Temporary files that have no value after a container’s lifecycle ends are well suited to ephemeral storage. This keeps transient data separate from persistent application state and simplifies cleanup when containers are replaced. Persistent volumes are appropriate when information must survive container recreation, such as databases or durable application state. Temporary data should still be managed carefully so it does not exhaust local storage during the container’s lifetime. Containerized automation benefits from explicitly distinguishing ephemeral data, persistent state, configuration, and secrets rather than treating all files as equally durable.<\/span><\/p>\n

                          Q273. An internal automation API needs to verify client certificates issued by the organization’s private CA. What must the server have available?<\/b><\/p>\n

                            \n
                          1. <\/b> The trust chain or CA certificates needed to validate client certificates<\/span>
                            \n<\/span>2.<\/b> Every client’s private key<\/span>
                            \n<\/span>3.<\/b> The Git repository password<\/span>
                            \n<\/span>4.<\/b> The Terraform state file<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. The trust chain or CA certificates needed to validate client certificates<\/b><\/p>\n

                            Explanation:<\/b> In mutual TLS, a server validates a client certificate by building a chain of trust to an accepted certificate authority and applying any configured identity or certificate policy. The server therefore needs the appropriate trusted CA certificates or chain information. It must never possess clients’ private keys; each client should protect its own private key. Trusting the CA does not automatically authorize every certificate holder to perform every API action, so certificate identity should still map to application authorization. PKI-based authentication combines certificate validation with appropriate permissions and lifecycle controls.<\/span><\/p>\n

                            Q274. A local LLM repeatedly generates different network recommendations even though the same prompt is submitted. Which parameter can often be lowered to make generation more deterministic?<\/b><\/p>\n

                              \n
                            1. <\/b> VLAN ID<\/span>
                              \n<\/span>2.<\/b> Temperature<\/span>
                              \n<\/span>3.<\/b> Syslog facility<\/span>
                              \n<\/span>4.<\/b> TLS certificate serial number<\/span><\/li>\n<\/ol>\n

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

                              Explanation:<\/b> In many generative AI systems, temperature controls randomness in token selection. Lower temperature values typically make generation more focused and repeatable, while higher values encourage greater variation. Lowering temperature can therefore help when automation workflows require more consistent output. It does not guarantee correctness or perfect determinism, and some model providers expose different sampling controls. Network automation code and recommendations must still be validated regardless of generation settings. Cisco’s AUTOCOR scope now explicitly includes AI in automation, including building network automation solutions with LLMs and evaluating their recommendations.<\/span><\/p>\n

                              Q275. A retrieval system splits a 500-page network design guide into smaller pieces before generating embeddings. Why is chunking useful?<\/b><\/p>\n

                                \n
                              1. <\/b> It automatically authorizes every document user<\/span>
                                \n<\/span>2.<\/b> It eliminates the need for embeddings<\/span>
                                \n<\/span>3.<\/b> It allows retrieval to return focused relevant sections instead of an entire large document<\/span>
                                \n<\/span>4.<\/b> It guarantees that retrieved information is current<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. It allows retrieval to return focused relevant sections instead of an entire large document<\/b><\/p>\n

                                Explanation:<\/b> Chunking divides long documents into smaller units suitable for embedding, indexing, and retrieval. When a user asks a specific routing or automation question, semantic search can return only the chunks most relevant to that query instead of placing an entire large document into the model’s context. Chunk size and overlap must be chosen carefully because overly small chunks can lose context while overly large chunks can dilute relevance. Chunking does not enforce authorization or freshness by itself. Those concerns require separate metadata, access-control, and document-lifecycle mechanisms.<\/span><\/p>\n

                                Q276. An AI network agent can choose among several diagnostic tools. Which design best reduces unnecessary tool calls?<\/b><\/p>\n

                                  \n
                                1. <\/b> Clearly describe each tool’s purpose, parameters, and appropriate usage conditions<\/span>
                                  \n<\/span>2.<\/b> Give every tool the same vague description<\/span>
                                  \n<\/span>3.<\/b> Remove parameter schemas<\/span>
                                  \n<\/span>4.<\/b> Allow tools to call themselves indefinitely<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Clearly describe each tool’s purpose, parameters, and appropriate usage conditions<\/b><\/p>\n

                                  Explanation:<\/b> AI agents select tools more reliably when each tool has a clear description and well-defined schema. The model can better distinguish, for example, between a tool that retrieves routes and one that retrieves interface counters. Vague descriptions increase the chance of incorrect or unnecessary calls. The server should still enforce authorization, limits, and parameter validation because descriptions only guide the model; they do not provide security. Good tool design reduces wasted queries and improves agent reliability by making the mapping between user intent and available deterministic capabilities clearer.<\/span><\/p>\n

                                  Q277. An AI assistant retrieves five documents for an OSPF question. The application wants to show operators which evidence supported the answer. What feature should it preserve?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Source provenance and citations for retrieved context<\/span>
                                    \n<\/span>2.<\/b> Only the model’s hidden token probabilities<\/span>
                                    \n<\/span>3.<\/b> Unrelated Git metadata<\/span>
                                    \n<\/span>4.<\/b> Random document ordering with no identity information<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 4. Source provenance and citations for retrieved context<\/b><\/p>\n

                                    Explanation:<\/b> Preserving source provenance allows users to see which documents, versions, or operational sources contributed to an AI-generated answer. This improves auditability and allows engineers to verify whether the evidence is current and authoritative. Provenance can include document title, version, source system, timestamp, or retrieval identifier. It is especially useful when multiple standards or design guides exist. An answer without visible evidence may sound convincing but can be difficult to validate. For operational AI, grounded responses should make it practical for users to distinguish retrieved facts from model-generated reasoning or recommendations.<\/span><\/p>\n

                                    Q278. An AI agent can propose router configuration but must never execute a command that is outside an approved command catalog. Where should this policy be enforced?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Only in a conversational reminder<\/span>
                                      \n<\/span>2.<\/b> In deterministic tool-side authorization and command validation<\/span>
                                      \n<\/span>3.<\/b> By increasing the model context window<\/span>
                                      \n<\/span>4.<\/b> By asking the user to trust the model<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. In deterministic tool-side authorization and command validation<\/b><\/p>\n

                                      Explanation:<\/b> A language model should not be the final enforcement point for infrastructure permissions. The execution tool or automation backend should compare requested actions against an approved command or operation catalog and reject anything outside that policy. This safeguard remains effective even if the model hallucinates, misunderstands a request, or is manipulated through prompt injection. Model instructions can reduce unwanted behavior but cannot replace deterministic authorization. High-impact operations may additionally require explicit human approval, target validation, logging, rollback, and post-change testing.<\/span><\/p>\n

                                      Q279. An organization evaluates an AI troubleshooting assistant. The model provides the correct root cause in 95 of 100 independently verified test scenarios. Which metric is being measured most directly?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Storage utilization<\/span>
                                        \n<\/span>2.<\/b> Tool-call latency<\/span>
                                        \n<\/span>3.<\/b> Technical accuracy on the evaluation set<\/span>
                                        \n<\/span>4.<\/b> Network packet loss<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Technical accuracy on the evaluation set<\/b><\/p>\n

                                        Explanation:<\/b> If the model produces the independently verified correct answer in 95 out of 100 test cases, the organization is measuring its technical accuracy on that particular benchmark. The benchmark should represent realistic operational scenarios and should remain separate from any examples used to tune the system. Additional metrics such as unsafe-action rate, latency, tool-call accuracy, and consistency may also matter. A 95% result does not mean the system is safe for unrestricted automation; the consequences of the remaining errors must be considered when selecting autonomy and approval controls.<\/span><\/p>\n

                                        Q280. A network AI agent is allowed to remediate an issue automatically only when deterministic tests confirm the diagnosis and the proposed action is classified as low risk. What principle does this architecture demonstrate?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Unrestricted autonomous control<\/span>
                                          \n<\/span>2.<\/b> Guarded autonomy based on validation and risk<\/span>
                                          \n<\/span>3.<\/b> Elimination of infrastructure policy<\/span>
                                          \n<\/span>4.<\/b> Trusting model confidence without evidence<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. Guarded autonomy based on validation and risk<\/b><\/p>\n

                                          Explanation:<\/b> Guarded autonomy allows an AI agent to act independently only inside carefully defined boundaries. Deterministic tests verify the network condition, policy identifies the action as low risk, and tool permissions restrict what the agent can execute. Higher-risk operations can require human approval or separate workflows. This architecture captures the productivity benefits of AI without treating probabilistic model output as sufficient authorization. Logging and post-action validation should also confirm what happened. As Cisco’s current AUTOCOR exam includes AI in automation, understanding how AI capabilities integrate safely with deterministic network automation is increasingly important.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q261. An Ansible play targets 50 routers, but an API request must originate from the automation controller rather than from each router. Which Ansible keyword is most appropriate for running that task on the controller? run_once 2. delegate_to: localhost 3. serial 4. notify […]<\/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\/18189"}],"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=18189"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18189\/revisions"}],"predecessor-version":[{"id":18190,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18189\/revisions\/18190"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18189"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18189"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18189"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}