{"id":18193,"date":"2026-09-22T05:59:34","date_gmt":"2026-09-22T05:59:34","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18193"},"modified":"2026-09-22T05:59:34","modified_gmt":"2026-09-22T05:59:34","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part16-q301-320","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part16-q301-320\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part16 Q301-320"},"content":{"rendered":"

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


\n<\/b>Q301. An Ansible project contains common interface-configuration tasks, templates, defaults, and handlers that must be reused across several playbooks. Which Ansible construct is best suited to packaging this reusable content?<\/b><\/p>\n

    \n
  1. <\/b> Inventory alias<\/span>
    \n<\/span>2.<\/b> Role<\/span>
    \n<\/span>3.<\/b> Registered variable<\/span>
    \n<\/span>4.<\/b> Ad hoc command<\/span><\/li>\n<\/ol>\n

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

    Explanation:<\/b> Ansible roles provide a structured way to package reusable automation content such as tasks, handlers, templates, files, defaults, and variables. A role can be included by multiple playbooks, making common network automation easier to maintain and test. For example, an interface-management role can standardize descriptions, addressing, and validation logic across several site deployment playbooks. Registered variables store task results and do not package reusable automation. Inventory aliases identify hosts, while ad hoc commands are intended for individual operations rather than maintainable automation structure. Roles improve modularity and reduce duplicated configuration logic.<\/span><\/p>\n

    Q302. A Terraform team wants developers to maintain separate logical state instances for development and testing while using the same Terraform configuration. Which Terraform feature can provide this separation?<\/b><\/p>\n

      \n
    1. <\/b> Output variables<\/span>
      \n<\/span>2.<\/b> Provider aliases only<\/span>
      \n<\/span>3.<\/b> Lifecycle ignore rules<\/span>
      \n<\/span>4.<\/b> Workspaces<\/span><\/li>\n<\/ol>\n

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

      Explanation:<\/b> Terraform workspaces allow multiple state instances to be associated with the same configuration. They can be useful for separating similar environments such as development and testing when the overall configuration structure is shared. Each workspace maintains its own state, so resources created in one workspace are tracked separately from another. Workspaces are not always the best choice for strongly isolated production environments, where separate configurations or backends may provide clearer boundaries. Provider aliases select alternate provider configurations, outputs expose values, and lifecycle rules affect resource behavior rather than creating separate state instances.<\/span><\/p>\n

      Q303. A YANG model defines a <\/b>leaf-list<\/b> containing multiple DNS server addresses. How is this data most naturally represented in JSON?<\/b><\/p>\n

        \n
      1. <\/b> As an array of scalar values<\/span>
        \n<\/span>2.<\/b> As one comma-separated string only<\/span>
        \n<\/span>3.<\/b> As an HTTP cookie<\/span>
        \n<\/span>4.<\/b> As a Git tag<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. As an array of scalar values<\/b><\/p>\n

        Explanation:<\/b> A YANG <\/span>leaf-list<\/span> represents multiple values of the same leaf type. In JSON encoding, it is naturally represented as an array containing scalar values such as strings, integers, or addresses according to the YANG type. This differs from a YANG <\/span>list<\/span>, whose entries often become arrays of structured objects. Preserving the modeled type is important because RESTCONF and other model-driven automation rely on predictable structure and semantics. Converting the values into one arbitrary comma-separated string would discard the modeled collection structure and could cause validation or interoperability problems.<\/span><\/p>\n

        Q304. A Python network automation program repeatedly opens and closes API sessions in several functions. The team wants one custom object to automatically allocate and release a session when used with a <\/b>with<\/b> statement. What should the object implement?<\/b><\/p>\n

          \n
        1. <\/b> Only a global variable<\/span>
          \n<\/span>2.<\/b> A list comprehension<\/span>
          \n<\/span>3.<\/b> Context manager behavior<\/span>
          \n<\/span>4.<\/b> A recursive function with no termination condition<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Context manager behavior<\/b><\/p>\n

          Explanation:<\/b> Python context managers define setup and cleanup behavior associated with a <\/span>with<\/span> block. A custom API-session class can establish a connection or allocate resources on entry and then reliably close the session when execution leaves the block, including during exceptions. Context managers are commonly implemented with <\/span>__enter__<\/span> and <\/span>__exit__<\/span>, or by using utilities from <\/span>contextlib<\/span>. This centralizes resource management and reduces the chance that sessions remain open after errors. Reusable cleanup behavior is valuable in automation applications that communicate with many controllers and devices over long-running workflows.<\/span><\/p>\n

          Q305. A REST API supports both <\/b>Accept<\/b> and <\/b>Content-Type<\/b> headers. Which statement correctly describes their roles?<\/b><\/p>\n

            \n
          1. <\/b> Both headers identify only authentication methods<\/span>
            \n<\/span>2.<\/b> Accept<\/span> specifies the desired response format, while <\/span>Content-Type<\/span> identifies the request body format<\/span>
            \n<\/span>3.<\/b> Accept<\/span> is used only for rate limiting<\/span>
            \n<\/span>4.<\/b> Content-Type<\/span> identifies the Git branch being deployed<\/span><\/li>\n<\/ol>\n

            Correct Answer: 2. <\/b>Accept<\/b> specifies the desired response format, while <\/b>Content-Type<\/b> identifies the request body format<\/b><\/p>\n

            Explanation:<\/b> The <\/span>Content-Type<\/span> header tells the server how to interpret the data contained in the request body, while the <\/span>Accept<\/span> header tells the server which response media types the client can consume. In RESTCONF and other structured APIs, using the correct media types is essential because JSON and XML representations may have specific registered formats. A request can be syntactically correct but still fail if headers do not match the expected content. These headers do not provide authentication or rate limiting and have no relationship to source-control branches.<\/span><\/p>\n

            Q306. A Git engineer accidentally deletes a local branch and later realizes an important commit was not pushed anywhere. Which Git feature may help locate the commit if Git’s local reference history still contains it?<\/b><\/p>\n

              \n
            1. <\/b> git reflog<\/span>
              \n<\/span>2.<\/b> .gitignore<\/span>
              \n<\/span>3.<\/b> git clean<\/span>
              \n<\/span>4.<\/b> git init<\/span><\/li>\n<\/ol>\n

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

              Explanation:<\/b> Git’s reflog records updates to local references such as branch tips and <\/span>HEAD<\/span>. Even after a branch is deleted or reset, the reflog may still contain the commit identifier needed to recover work, provided the relevant objects have not yet been garbage collected. An engineer can inspect reflog entries, locate the previous commit, and create a new branch or tag referencing it. <\/span>.gitignore<\/span> controls untracked files, <\/span>git clean<\/span> removes them, and <\/span>git init<\/span> creates a repository. Reflog is therefore a valuable recovery tool for local history mistakes.<\/span><\/p>\n

              Q307. A GitLab pipeline has independent lint, unit-test, and schema-validation jobs. The integration test should begin as soon as all three required jobs complete rather than waiting for unrelated jobs in the same stage. Which GitLab feature best supports this dependency graph?<\/b><\/p>\n

                \n
              1. <\/b> .gitignore<\/span>
                \n<\/span>2.<\/b> Git stash<\/span>
                \n<\/span>3.<\/b> Manual router login<\/span>
                \n<\/span>4.<\/b> Explicit job dependencies using <\/span>needs<\/span><\/li>\n<\/ol>\n

                Correct Answer: 4. Explicit job dependencies using <\/b>needs<\/b><\/p>\n

                Explanation:<\/b> GitLab’s <\/span>needs<\/span> keyword allows jobs to declare explicit dependencies and can create a directed acyclic graph for pipeline execution. A downstream integration job can begin when its actual prerequisites finish instead of waiting for every job in an earlier stage. This can reduce pipeline duration while preserving required validation order. The dependency relationship should still ensure failed prerequisite jobs prevent unsafe downstream work. Source-control ignore rules and stashes do not control pipeline scheduling. Efficient CI\/CD design combines correct safety gates with parallelism where jobs are genuinely independent.<\/span><\/p>\n

                Q308. A Cisco Modeling Labs test includes two redundant WAN links. The automation team wants to prove traffic moves to the backup link when the primary fails. What is the most meaningful validation?<\/b><\/p>\n

                  \n
                1. <\/b> Check only that the CML nodes booted successfully<\/span>
                  \n<\/span>2.<\/b> Confirm the topology file exists<\/span>
                  \n<\/span>3.<\/b> Disable the primary link and verify routing and reachability converge through the backup path<\/span>
                  \n<\/span>4.<\/b> Check the Git repository size<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Disable the primary link and verify routing and reachability converge through the backup path<\/b><\/p>\n

                  Explanation:<\/b> High-availability testing should verify the operational outcome, not simply whether devices are running. In CML, the team can deliberately fail the primary path and then use routing checks, reachability tests, or pyATS validation to confirm the expected backup route becomes active. The workflow can also measure convergence behavior and restore the link afterward. This type of fault injection provides stronger evidence than checking topology startup alone. Simulated failure testing helps identify automation, routing, or validation defects before equivalent conditions occur in production.<\/span><\/p>\n

                  Q309. A telemetry platform receives values from devices using different units, such as bandwidth in bits per second from one source and kilobits per second from another. What should happen before cross-device analytics are performed?<\/b><\/p>\n

                    \n
                  1. <\/b> Normalize the measurements to consistent units<\/span>
                    \n<\/span>2.<\/b> Combine the raw values without conversion<\/span>
                    \n<\/span>3.<\/b> Delete unit metadata<\/span>
                    \n<\/span>4.<\/b> Convert all values into text strings<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. Normalize the measurements to consistent units<\/b><\/p>\n

                    Explanation:<\/b> Analytics are meaningful only when equivalent metrics use compatible units. Combining bits per second and kilobits per second without normalization produces incorrect comparisons, thresholds, and aggregate calculations. A telemetry processing pipeline should preserve unit metadata and convert measurements to a standard representation before analysis. Similar normalization may be needed for timestamps, interface identifiers, or platform-specific labels. Structured telemetry simplifies machine processing, but data-quality controls remain essential. Poor normalization can produce misleading alerts even when every raw measurement was collected accurately from its original source.<\/span><\/p>\n

                    Q310. An automation service sends important events to a remote Syslog server over TCP. What advantage does TCP generally provide compared with UDP for this use case?<\/b><\/p>\n

                      \n
                    1. <\/b> It guarantees that the application logic is correct<\/span>
                      \n<\/span>2.<\/b> It provides connection-oriented delivery with retransmission behavior<\/span>
                      \n<\/span>3.<\/b> It eliminates the need for log retention<\/span>
                      \n<\/span>4.<\/b> It automatically encrypts all Syslog traffic<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 4. It provides connection-oriented delivery with retransmission behavior<\/b><\/p>\n

                      Explanation:<\/b> TCP provides connection-oriented transport with acknowledgments and retransmission mechanisms, making it more reliable than best-effort UDP when network loss occurs. However, TCP itself does not encrypt Syslog; TLS is needed when confidentiality and authenticated transport are required. Reliable transport also does not guarantee that the remote logging application successfully stored or processed every event, so system-level monitoring remains necessary. Logging architecture should consider reliability, security, backpressure, retention, and failure handling rather than selecting a protocol based only on simplicity.<\/span><\/p>\n

                      Q311. A pyATS test suite validates BGP neighbors, but some routers intentionally have two peers while others have four. How should expected values be supplied?<\/b><\/p>\n

                        \n
                      1. <\/b> Hard-code the same peer count for every router<\/span>
                        \n<\/span>2.<\/b> Store device-specific expectations in structured test data or the source of truth<\/span>
                        \n<\/span>3.<\/b> Ignore neighbor count entirely<\/span>
                        \n<\/span>4.<\/b> Fail every device with more than two peers<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. Store device-specific expectations in structured test data or the source of truth<\/b><\/p>\n

                        Explanation:<\/b> Validation should compare actual state against the intended state for each device rather than assuming every router has identical requirements. Device-specific expectations can come from a test-data file, inventory system, or authoritative source of truth. The test logic remains reusable while input data describes how many peers each device should have. This separation improves maintainability and avoids duplicating test code. Hard-coding one value for all routers would produce false failures or false successes when network roles differ. Good automation combines reusable validation logic with authoritative per-device expectations.<\/span><\/p>\n

                        Q312. A Python automation service needs to retry a failed API request up to three times with delays of 1, 2, and 4 seconds. Which retry strategy does this represent?<\/b><\/p>\n

                          \n
                        1. <\/b> Constant polling<\/span>
                          \n<\/span>2.<\/b> Infinite retry<\/span>
                          \n<\/span>3.<\/b> Exponential backoff<\/span>
                          \n<\/span>4.<\/b> Random device selection<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. Exponential backoff<\/b><\/p>\n

                          Explanation:<\/b> Exponential backoff increases the wait between consecutive retries, commonly by multiplying the previous delay. A sequence such as 1, 2, and 4 seconds is a basic example. This strategy reduces pressure on an overloaded or temporarily unavailable service compared with immediate repeated requests. Production implementations often add jitter to avoid many clients retrying simultaneously. Retries should be bounded and applied only to conditions that are reasonably transient. Authentication failures, invalid input, or permanent authorization errors generally require corrective action rather than automatic repeated attempts.<\/span><\/p>\n

                          Q313. A Docker image for a network automation application is built using several stages. What is a major benefit of a multi-stage build?<\/b><\/p>\n

                            \n
                          1. <\/b> The final image can exclude build tools and unnecessary intermediate files<\/span>
                            \n<\/span>2.<\/b> Containers no longer require an operating-system runtime<\/span>
                            \n<\/span>3.<\/b> Every container automatically gains root privileges<\/span>
                            \n<\/span>4.<\/b> Git history is embedded automatically<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 4. The final image can exclude build tools and unnecessary intermediate files<\/b><\/p>\n

                            Explanation:<\/b> Multi-stage Docker builds allow compilation or dependency-building tools to exist in an earlier stage while only the required runtime artifacts are copied into the final image. This can substantially reduce image size and attack surface. A smaller runtime image is easier to distribute and may contain fewer packages requiring vulnerability management. Multi-stage builds do not eliminate the need for a runtime environment or secure configuration, and they should not be used to add unnecessary privileges. Container security also depends on trusted base images, scanning, secrets handling, and runtime permissions.<\/span><\/p>\n

                            Q314. An automation service has separate readiness and liveness checks. What is the primary purpose of a readiness check?<\/b><\/p>\n

                              \n
                            1. <\/b> Determine whether the service should currently receive traffic or work<\/span>
                              \n<\/span>2.<\/b> Prove the source code contains no vulnerabilities<\/span>
                              \n<\/span>3.<\/b> Replace application monitoring entirely<\/span>
                              \n<\/span>4.<\/b> Determine the Git commit author<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. Determine whether the service should currently receive traffic or work<\/b><\/p>\n

                              Explanation:<\/b> A readiness check indicates whether an application is prepared to accept requests or perform work. A service can be alive but not ready, for example while it is still loading configuration or waiting for a required backend dependency. Load balancers or orchestrators can use readiness status to avoid sending traffic prematurely. Liveness checks answer a different question: whether the process appears healthy enough to continue running or may require restart. Separating these concepts can prevent unnecessary restarts and reduce failed requests during application initialization or temporary dependency conditions.<\/span><\/p>\n

                              Q315. A local LLM can answer network questions accurately, but a much smaller model achieves nearly identical results while using less GPU memory. Which operational advantage does the smaller model provide?<\/b><\/p>\n

                                \n
                              1. <\/b> It removes all need for testing<\/span>
                                \n<\/span>2.<\/b> It guarantees zero hallucinations<\/span>
                                \n<\/span>3.<\/b> Reduced compute and memory requirements<\/span>
                                \n<\/span>4.<\/b> Unlimited context size<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3. Reduced compute and memory requirements<\/b><\/p>\n

                                Explanation:<\/b> Smaller models generally require less memory and compute capacity, which can lower hardware costs and improve inference speed or deployment flexibility. If evaluation shows that a smaller model provides comparable technical accuracy for the target network tasks, it may be more practical for local automation use. Model selection should be based on measured quality, latency, resource consumption, context needs, and security constraints rather than assuming larger is always better. Smaller models can still hallucinate and require the same validation, authorization, retrieval, and tool-safety controls as larger language models.<\/span><\/p>\n

                                Q316. A retrieval system initially finds 50 semantically similar network-document chunks. The application wants a more precise final set of five chunks before passing context to the LLM. Which technique is useful?<\/b><\/p>\n

                                  \n
                                1. <\/b> Remove all retrieval scoring<\/span>
                                  \n<\/span>2.<\/b> Apply a reranking step to prioritize the most relevant results<\/span>
                                  \n<\/span>3.<\/b> Send all documents regardless of relevance<\/span>
                                  \n<\/span>4.<\/b> Randomly choose five chunks<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 2. Apply a reranking step to prioritize the most relevant results<\/b><\/p>\n

                                  Explanation:<\/b> Retrieval systems often use an initial semantic search for broad recall and then apply reranking to improve precision. A reranker evaluates the query and candidate chunks more closely and orders them so the most relevant evidence is supplied to the model. This can reduce context-window waste and improve grounded answer quality. Reranking does not replace freshness checks, provenance, authorization filtering, or prompt-injection defenses. The retrieval pipeline should first ensure the user is authorized to access the content, then select current authoritative material and rank it appropriately for the question.<\/span><\/p>\n

                                  Q317. An MCP server returns detailed error messages containing internal controller URLs and authentication metadata. What should be improved?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Return even more internal secrets for debugging<\/span>
                                    \n<\/span>2.<\/b> Make every error public<\/span>
                                    \n<\/span>3.<\/b> Remove all error reporting<\/span>
                                    \n<\/span>4.<\/b> Sanitize tool errors while preserving useful non-sensitive diagnostic information<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 4. Sanitize tool errors while preserving useful non-sensitive diagnostic information<\/b><\/p>\n

                                    Explanation:<\/b> Error responses should provide enough information for the AI agent and operators to understand what failed without leaking credentials, internal tokens, private URLs, or other sensitive implementation details. The MCP server can log richer diagnostics to a protected backend while returning a sanitized error to the caller. Completely hiding errors makes troubleshooting difficult, whereas exposing secrets expands the impact of failures. AI-integrated tooling should follow the same secure coding principles as other APIs: validate input, enforce authorization, limit output, sanitize errors, and maintain controlled audit logs.<\/span><\/p>\n

                                    Q318. An AI network agent has confidence scores from a classifier that predicts whether a proposed change is low risk. What should the system do before using those scores as an approval threshold?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Validate and calibrate the scores against representative labeled outcomes<\/span>
                                      \n<\/span>2.<\/b> Assume a score of 0.9 always means exactly 90% real-world safety<\/span>
                                      \n<\/span>3.<\/b> Remove all deterministic controls<\/span>
                                      \n<\/span>4.<\/b> Let the model redefine the threshold during execution<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Validate and calibrate the scores against representative labeled outcomes<\/b><\/p>\n

                                      Explanation:<\/b> Model confidence values do not automatically correspond to real-world probabilities. Before using them to control network-change autonomy, the organization should evaluate how predicted confidence aligns with actual outcomes on representative data. Calibration testing can reveal whether high-confidence predictions are genuinely more reliable and where thresholds should be placed. Even a well-calibrated score should not replace deterministic authorization, scope checks, policy constraints, and validation for high-impact actions. AI metrics must be interpreted empirically rather than assumed to have an intuitive probability meaning.<\/span><\/p>\n

                                      Q319. A network AI assistant receives current device state from a trusted tool and a conflicting statement from an old troubleshooting document. Which evidence should be prioritized for a question about the device’s current status?<\/b><\/p>\n

                                        \n
                                      1. <\/b> The current validated device state<\/span>
                                        \n<\/span>2.<\/b> The older document because it contains more text<\/span>
                                        \n<\/span>3.<\/b> Whichever source appears first in the context<\/span>
                                        \n<\/span>4.<\/b> The model’s pretrained memory<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. The current validated device state<\/b><\/p>\n

                                        Explanation:<\/b> Questions about current operational status should rely primarily on fresh authoritative evidence. A troubleshooting document may explain general behavior, but it cannot override direct validated device state when determining whether an interface, route, or neighbor is currently active. Retrieval systems should preserve metadata such as source type, timestamp, and authority so the AI can distinguish live evidence from background documentation. When data conflicts, the assistant should explain the discrepancy rather than blend incompatible facts. Grounding network answers in current trusted state reduces hallucination and improves operator confidence.<\/span><\/p>\n

                                        Q320. An AI agent can create a proposed Terraform plan, but production policy requires that only a separate deployment service may execute <\/b>terraform apply<\/b>. What security principle does this architecture demonstrate?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Shared unrestricted administrator access<\/span>
                                          \n<\/span>2.<\/b> Disabling change control<\/span>
                                          \n<\/span>3.<\/b> Separation of duties between planning and execution<\/span>
                                          \n<\/span>4.<\/b> Removing auditability<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Separation of duties between planning and execution<\/b><\/p>\n

                                          Explanation:<\/b> Separating plan generation from execution prevents one component from controlling the entire change lifecycle. The AI agent can interpret intent and prepare a proposed Terraform change, while an independently authorized deployment service validates and applies approved plans. This reduces the impact of model errors or compromised conversational sessions and provides clearer governance boundaries. The execution service can enforce policy, target scope, credentials, approval, and locking without relying on the LLM. Separation of duties is particularly valuable for high-impact Infrastructure as Code workflows where a single command can change many production resources.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q301. An Ansible project contains common interface-configuration tasks, templates, defaults, and handlers that must be reused across several playbooks. Which Ansible construct is best suited to packaging this reusable content? Inventory alias 2. Role 3. Registered variable 4. Ad hoc command Correct Answer: […]<\/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\/18193"}],"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=18193"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18193\/revisions"}],"predecessor-version":[{"id":18194,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18193\/revisions\/18194"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18193"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18193"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18193"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}