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

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


\n<\/b>Q221. An Ansible playbook contains troubleshooting tasks that should run only when an engineer explicitly requests them during execution. Which Ansible feature is best suited to this requirement?<\/b><\/p>\n

    \n
  1. <\/b> Handlers<\/span>
    \n<\/span>2.<\/b> Tags<\/span>
    \n<\/span>3.<\/b> Registered variables<\/span>
    \n<\/span>4.<\/b> Inventory aliases<\/span><\/li>\n<\/ol>\n

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

    Explanation:<\/b> Ansible tags allow selected tasks, roles, or portions of a playbook to be executed or skipped from the command line. An engineer can tag troubleshooting tasks with a name such as <\/span>diagnostics<\/span> and run only those tasks when required. This keeps optional operational actions inside the same maintainable playbook without forcing them to execute during every normal deployment. Handlers are triggered by task notifications, while registered variables store results from earlier tasks. Tags are particularly useful in larger network automation workflows where configuration, validation, troubleshooting, and reporting tasks must be selectively executed.<\/span><\/p>\n

    Q222. A Terraform output contains a generated API credential that must not be displayed automatically in normal command output. Which Terraform setting should be applied to the output?<\/b><\/p>\n

      \n
    1. <\/b> count = 0<\/span>
      \n<\/span>2.<\/b> create_before_destroy = true<\/span>
      \n<\/span>3.<\/b> depends_on = []<\/span>
      \n<\/span>4.<\/b> sensitive = true<\/span><\/li>\n<\/ol>\n

      Correct Answer: 4. <\/b>sensitive = true<\/b><\/p>\n

      Explanation:<\/b> Marking a Terraform output as sensitive prevents Terraform from displaying its value openly in normal CLI output. This reduces accidental credential disclosure in terminals, CI\/CD logs, and screenshots. However, the value can still exist in Terraform state, so state storage itself must be protected with appropriate encryption and access controls. The <\/span>sensitive<\/span> flag is therefore an output-handling protection rather than a complete secret-management solution. Credentials should ideally be generated and stored through dedicated secret-management systems when possible. Terraform lifecycle and dependency settings do not provide this type of output redaction.<\/span><\/p>\n

      Q223. An automation client reads a RESTCONF resource, modifies it, and wants to ensure no other process changed the resource before the update is submitted. Which HTTP mechanism best supports optimistic concurrency control?<\/b><\/p>\n

        \n
      1. <\/b> Use an ETag and send it back with an <\/span>If-Match<\/span> header<\/span>
        \n<\/span>2.<\/b> Disable response headers<\/span>
        \n<\/span>3.<\/b> Use HTTP TRACE before every update<\/span>
        \n<\/span>4.<\/b> Reboot the network device first<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. Use an ETag and send it back with an <\/b>If-Match<\/b> header<\/b><\/p>\n

        Explanation:<\/b> An ETag identifies a particular version of an HTTP resource. A client can retrieve the resource and its ETag, then include that ETag in an <\/span>If-Match<\/span> header when submitting an update. The server can reject the request if the resource has changed since the client originally read it. This prevents one automation process from unknowingly overwriting another process’s more recent update. The exact implementation depends on server capabilities, but optimistic concurrency is valuable in multi-user automation environments where several workflows may target the same configuration resources concurrently.<\/span><\/p>\n

        Q224. A NETCONF automation workflow performs several related edits. The engineer wants to prevent another NETCONF session from changing the same datastore during the transaction. Which NETCONF operation should be used?<\/b><\/p>\n

          \n
        1. <\/b> <get><\/span>
          \n<\/span>2.<\/b> <close-session><\/span>
          \n<\/span>3.<\/b> <lock><\/span>
          \n<\/span>4.<\/b> <kill-session><\/span><\/li>\n<\/ol>\n

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

          Explanation:<\/b> NETCONF provides the <\/span><lock><\/span> operation to obtain exclusive access to a datastore when the server supports locking. This helps prevent other NETCONF sessions from modifying that datastore while a coordinated set of configuration changes is being prepared or committed. After the transaction completes, the client should release the datastore using <\/span><unlock><\/span>. Locking should not be held unnecessarily because it can block legitimate management activity. <\/span><get><\/span> retrieves data, while session-closing operations terminate sessions rather than protecting a datastore. Transaction control is one advantage of model-driven network management compared with loosely coordinated CLI automation.<\/span><\/p>\n

          Q225. A Python network automation function must process device records one at a time from a very large dataset without loading the entire result into memory. Which Python feature is most appropriate?<\/b><\/p>\n

            \n
          1. <\/b> Global variables<\/span>
            \n<\/span>2.<\/b> Recursion without a base case<\/span>
            \n<\/span>3.<\/b> Deep copying the entire dataset<\/span>
            \n<\/span>4.<\/b> A generator<\/span><\/li>\n<\/ol>\n

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

            Explanation:<\/b> Generators produce values lazily, meaning items can be processed one at a time instead of creating and storing an entire collection in memory. This is valuable when network automation consumes large inventories, telemetry datasets, or paginated API responses. A generator can yield each device record as it becomes available, allowing downstream logic to operate with a smaller memory footprint. Generators can be implemented with <\/span>yield<\/span> or generator expressions. They do not automatically solve API pagination or error handling, but they provide an efficient programming model for sequentially processing large data streams.<\/span><\/p>\n

            Q226. A Git repository requires evidence that a release commit was created by an approved engineer and has not been impersonated easily. Which Git capability best supports this goal?<\/b><\/p>\n

              \n
            1. <\/b> .gitignore<\/span>
              \n<\/span>2.<\/b> Cryptographically signed commits or tags<\/span>
              \n<\/span>3.<\/b> git clean<\/span>
              \n<\/span>4.<\/b> Untracked files<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. Cryptographically signed commits or tags<\/b><\/p>\n

              Explanation:<\/b> Git can cryptographically sign commits or tags using supported signing mechanisms. Verification allows users and automation systems to determine whether the signature corresponds to a trusted signing identity. This can strengthen release provenance and help detect unauthorized or impersonated release metadata. Signed commits do not replace repository permissions, branch protections, code review, or artifact signing, but they add another layer of authenticity. <\/span>.gitignore<\/span> controls which files Git normally tracks, while <\/span>git clean<\/span> removes untracked files. Infrastructure as Code repositories benefit from strong traceability because their contents can directly influence production networks.<\/span><\/p>\n

              Q227. A GitLab pipeline should automatically run extra security validation whenever files under the <\/b>firewall\/<\/b> directory are modified. Which approach is most appropriate?<\/b><\/p>\n

                \n
              1. <\/b> Use pipeline job rules based on changed file paths<\/span>
                \n<\/span>2.<\/b> Run production deployment for every repository file change<\/span>
                \n<\/span>3.<\/b> Delete the firewall directory after validation<\/span>
                \n<\/span>4.<\/b> Disable branch awareness<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. Use pipeline job rules based on changed file paths<\/b><\/p>\n

                Explanation:<\/b> GitLab job rules can evaluate changed paths and conditionally include jobs in a pipeline. A security-validation job can therefore run only when files affecting firewall automation are modified. This creates faster pipelines while still applying additional scrutiny where it matters. The job can perform syntax checking, policy validation, simulation, or unit tests before deployment stages proceed. Path-based rules should complement, not replace, broader validation because changes elsewhere may still affect shared code. Encoding such conditions directly in CI\/CD configuration makes enforcement consistent rather than relying on engineers to remember when extra testing is required.<\/span><\/p>\n

                Q228. A Cisco Modeling Labs topology is used to test an automation workflow. The test requires a predictable initial router configuration on every pipeline run. What design best supports reproducibility?<\/b><\/p>\n

                  \n
                1. <\/b> Allow engineers to modify the lab manually between pipeline runs<\/span>
                  \n<\/span>2.<\/b> Reuse an unknown existing topology state<\/span>
                  \n<\/span>3.<\/b> Define and recreate the test topology and baseline configuration from version-controlled inputs<\/span>
                  \n<\/span>4.<\/b> Disable configuration initialization<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Define and recreate the test topology and baseline configuration from version-controlled inputs<\/b><\/p>\n

                  Explanation:<\/b> Reproducible testing requires a known starting state. Defining the CML topology and baseline configuration through version-controlled files or automation allows every pipeline run to begin from the same intended environment. This makes failed tests easier to reproduce and reduces hidden dependencies on manual lab changes. Persistent manually modified labs can accumulate configuration drift and cause identical automation code to produce different outcomes over time. A repeatable lab environment should be created, validated, used for testing, and cleaned up according to a controlled lifecycle.<\/span><\/p>\n

                  Q229. A telemetry platform receives data encoded as structured key-value fields rather than human-formatted CLI output. What is the primary benefit for automation?<\/b><\/p>\n

                    \n
                  1. <\/b> Devices no longer need network connectivity<\/span>
                    \n<\/span>2.<\/b> Software can process telemetry fields directly without fragile text parsing<\/span>
                    \n<\/span>3.<\/b> Telemetry storage becomes unnecessary<\/span>
                    \n<\/span>4.<\/b> Every network fault is automatically corrected<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2. Software can process telemetry fields directly without fragile text parsing<\/b><\/p>\n

                    Explanation:<\/b> Structured telemetry exposes modeled fields that collectors and analytics applications can process directly. This reduces dependence on screen scraping and regular-expression parsing of human-readable CLI output, both of which can break when formatting changes. Structured data enables reliable filtering, aggregation, alerting, dashboards, and automated decisions. The architecture must still consider schemas, encoding, transport, sampling rates, collector scale, and storage. Structured telemetry improves machine consumption but does not eliminate the need for connectivity, data retention, or explicit remediation logic.<\/span><\/p>\n

                    Q230. A company transmits sensitive Syslog messages across an untrusted network. Which design best protects the log data in transit?<\/b><\/p>\n

                      \n
                    1. <\/b> Use Syslog over a TLS-protected transport where supported<\/span>
                      \n<\/span>2.<\/b> Send logs using plaintext UDP only<\/span>
                      \n<\/span>3.<\/b> Place credentials directly inside each log message<\/span>
                      \n<\/span>4.<\/b> Disable centralized logging<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. Use Syslog over a TLS-protected transport where supported<\/b><\/p>\n

                      Explanation:<\/b> TLS can provide confidentiality, integrity, and authenticated transport for Syslog traffic when both the sender and receiver support an appropriate secure Syslog configuration. This is preferable when logs contain sensitive operational or security information and must cross untrusted networks. Traditional plaintext Syslog may expose message content and can provide weaker delivery guarantees depending on transport. Encryption does not replace access control or log sanitization; automation should still avoid writing passwords and tokens into logs. A complete logging architecture also considers retention, timestamps, availability, and collector authentication.<\/span><\/p>\n

                      Q231. A pyATS test needs to validate the same operational condition on 50 routers. Which testing design improves maintainability?<\/b><\/p>\n

                        \n
                      1. <\/b> Write 50 completely unrelated copies of the same test code<\/span>
                        \n<\/span>2.<\/b> Test one router and assume the remaining devices are identical<\/span>
                        \n<\/span>3.<\/b> Use a reusable test function or loop driven by the device list<\/span>
                        \n<\/span>4.<\/b> Remove the expected result from the test<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 4. Use a reusable test function or loop driven by the device list<\/b><\/p>\n

                        Explanation:<\/b> Reusable test logic driven by structured device data reduces duplication and makes large validation suites easier to maintain. The same expected-state check can be applied to each router while still recording device-specific results. When the test requirement changes, engineers can update one implementation instead of editing dozens of copies. Parameterized or loop-driven testing must still report failures clearly so operators know which device failed. Large-scale network automation depends on reusable validation because manual duplication becomes difficult to review and inconsistent as device counts increase.<\/span><\/p>\n

                        Q232. A Dockerized automation service repeatedly crashes because an external dependency is temporarily unavailable. The service should restart automatically after failure. Which container setting should be considered?<\/b><\/p>\n

                          \n
                        1. <\/b> Git branch protection<\/span>
                          \n<\/span>2.<\/b> An appropriate Docker restart policy<\/span>
                          \n<\/span>3.<\/b> Terraform import<\/span>
                          \n<\/span>4.<\/b> RESTCONF ETags<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. An appropriate Docker restart policy<\/b><\/p>\n

                          Explanation:<\/b> Docker restart policies control whether containers should restart automatically after failures or daemon restarts. Policies such as <\/span>on-failure<\/span> or other supported options can improve resilience for automation services that may temporarily terminate because of transient dependency problems. Restarting should not hide persistent defects; the application should log failures, use bounded retries internally where appropriate, and provide health checks so operators can detect recurring problems. A restart policy is an operational resilience mechanism for containerized services and is unrelated to Git governance, Terraform resource adoption, or RESTCONF concurrency controls.<\/span><\/p>\n

                          Q233. An internal automation service’s TLS certificate will expire in seven days. What is the most appropriate operational response?<\/b><\/p>\n

                            \n
                          1. <\/b> Renew and deploy a replacement certificate before expiration, then validate the service<\/span>
                            \n<\/span>2.<\/b> Wait for the certificate to expire before starting renewal<\/span>
                            \n<\/span>3.<\/b> Disable TLS permanently<\/span>
                            \n<\/span>4.<\/b> Reuse an unrelated server’s private key and certificate<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Renew and deploy a replacement certificate before expiration, then validate the service<\/b><\/p>\n

                            Explanation:<\/b> Certificate renewal should occur before expiration so clients do not experience avoidable trust failures. The replacement certificate should contain the correct identities, chain, and key material and should be deployed through a controlled process. After installation, operators should validate the service from the client perspective to confirm the new certificate is presented correctly. Automated expiration monitoring can prevent last-minute outages. Reusing another server’s credentials breaks identity boundaries, while disabling TLS removes important transport security. Certificate lifecycle management includes issuance, renewal, deployment, revocation, and private-key protection.<\/span><\/p>\n

                            Q234. An AI-powered network assistant converts network documents into numerical representations so semantically similar text can be searched efficiently. What are these representations called?<\/b><\/p>\n

                              \n
                            1. <\/b> Git hashes<\/span>
                              \n<\/span>2.<\/b> Terraform plans<\/span>
                              \n<\/span>3.<\/b> Docker layers<\/span>
                              \n<\/span>4.<\/b> Embeddings<\/span><\/li>\n<\/ol>\n

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

                              Explanation:<\/b> Embeddings are numerical vector representations that capture semantic relationships in data such as text. In retrieval-based AI systems, network documentation can be divided into chunks, transformed into embeddings, and stored in a vector-search system. When a user asks a question, the query can also be embedded and compared with document vectors to locate semantically relevant context. Embeddings do not themselves enforce access control or guarantee factual correctness. Retrieval architecture must still respect document permissions, freshness, provenance, and prompt-injection risks before retrieved material is supplied to the language model.<\/span><\/p>\n

                              Q235. A retrieval-augmented network assistant returns an answer based on a document that was superseded six months ago. Which improvement best addresses this problem?<\/b><\/p>\n

                                \n
                              1. <\/b> Increase model temperature<\/span>
                                \n<\/span>2.<\/b> Add freshness and document-version controls to the retrieval process<\/span>
                                \n<\/span>3.<\/b> Remove timestamps from all documents<\/span>
                                \n<\/span>4.<\/b> Ask the model to guess which document is newer<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. Add freshness and document-version controls to the retrieval process<\/b><\/p>\n

                                Explanation:<\/b> Retrieval quality depends not only on semantic similarity but also on source freshness and authority. A system can index document versions, update timestamps, lifecycle state, and approval status so obsolete documents are excluded or ranked below current authoritative material. Simply retrieving the most semantically similar text can produce technically outdated answers. The application should also expose source information where appropriate so operators can verify evidence. For network operations, stale routing standards or configuration guidance can be dangerous, so retrieval governance is an important part of trustworthy AI automation.<\/span><\/p>\n

                                Q236. An MCP server provides an AI agent with reusable instructions for performing a standardized troubleshooting interaction. Which MCP concept is most closely associated with reusable prompt templates?<\/b><\/p>\n

                                  \n
                                1. <\/b> Docker volume<\/span>
                                  \n<\/span>2.<\/b> Terraform output<\/span>
                                  \n<\/span>3.<\/b> Prompt<\/span>
                                  \n<\/span>4.<\/b> RESTCONF datastore<\/span><\/li>\n<\/ol>\n

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

                                  Explanation:<\/b> MCP can expose prompts in addition to resources and tools. Prompts provide reusable templates or structured interaction patterns that clients can present to users or models for particular tasks. For example, a troubleshooting prompt could define the information that should be collected before invoking diagnostic tools. Resources expose information, while tools provide callable capabilities. Prompt templates improve consistency but are not security boundaries. The MCP server and connected tools must still authenticate callers, validate arguments, enforce authorization, and log actions independently of any prompt instructions.<\/span><\/p>\n

                                  Q237. A local LLM used for network automation has a limited context window. What happens if the application tries to send more prompt and document content than the model can process?<\/b><\/p>\n

                                    \n
                                  1. <\/b> All content is always processed automatically<\/span>
                                    \n<\/span>2.<\/b> The model gains unlimited memory<\/span>
                                    \n<\/span>3.<\/b> Network devices expand the context window<\/span>
                                    \n<\/span>4.<\/b> Content must be reduced, summarized, chunked, or otherwise managed to fit the model’s context capacity<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 4. Content must be reduced, summarized, chunked, or otherwise managed to fit the model’s context capacity<\/b><\/p>\n

                                    Explanation:<\/b> Every LLM has a finite context capacity defining how much input and generated content can be considered in one interaction. Large configuration files, logs, and documentation may exceed that limit. Applications should therefore retrieve only relevant information, chunk large sources, summarize when appropriate, and reserve sufficient context for the model’s response. Simply sending everything can cause truncation, errors, unnecessary latency, or poor focus. Context-management strategy is important in network automation because operational data can be extremely large, particularly when telemetry, device configurations, and multiple documents are involved.<\/span><\/p>\n

                                    Q238. An AI agent asks an MCP tool to retrieve interface statistics for 10,000 devices even though the user asked about only one router. Which server-side control best limits this behavior?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Enforce parameter validation and maximum query-scope limits<\/span>
                                      \n<\/span>2.<\/b> Let the language model determine all resource limits<\/span>
                                      \n<\/span>3.<\/b> Disable authentication<\/span>
                                      \n<\/span>4.<\/b> Permit unlimited wildcard queries<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. Enforce parameter validation and maximum query-scope limits<\/b><\/p>\n

                                      Explanation:<\/b> Tool servers should enforce deterministic resource limits independently of the model. The MCP server can validate device identifiers, reject overly broad wildcard requests, limit result counts, and require additional authorization for expensive operations. These controls prevent hallucination, prompt injection, or simple mistakes from creating excessive load on controllers, telemetry systems, or devices. The user request itself can also be checked against the proposed tool call. AI reasoning should not determine infrastructure safety boundaries because models are probabilistic. Server-side limits provide predictable enforcement even when the model chooses an inappropriate query.<\/span><\/p>\n

                                      Q239. A network AI assistant produces an answer using three retrieved sources, but two sources disagree about the current standard. What is the best behavior?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Silently choose whichever source contains more words<\/span>
                                        \n<\/span>2.<\/b> Identify the conflict and prefer the authoritative current source according to defined provenance rules<\/span>
                                        \n<\/span>3.<\/b> Combine contradictory instructions into one configuration<\/span>
                                        \n<\/span>4.<\/b> Hide all source information from the operator<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Identify the conflict and prefer the authoritative current source according to defined provenance rules<\/b><\/p>\n

                                        Explanation:<\/b> Retrieval systems can surface contradictory information, especially when documentation has multiple revisions or comes from sources with different authority. The application should use metadata such as document owner, approval status, version, publication date, and source classification to determine which source is authoritative. When uncertainty remains, the assistant should expose the conflict rather than invent a resolution. This improves operator trust and reduces the chance that outdated guidance drives network changes. Provenance is essential when AI is used in operational environments where documentation directly influences production decisions.<\/span><\/p>\n

                                        Q240. An AI-generated automation plan targets the correct devices but requests 500 simultaneous configuration sessions, exceeding the controller’s safe concurrency limit of 50. Which response is best?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Increase concurrency to 1,000<\/span>
                                          \n<\/span>2.<\/b> Enforce the controller’s concurrency limit and process work in controlled batches<\/span>
                                          \n<\/span>3.<\/b> Disable controller protection<\/span>
                                          \n<\/span>4.<\/b> Allow the AI to bypass all rate and capacity limits<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. Enforce the controller’s concurrency limit and process work in controlled batches<\/b><\/p>\n

                                          Explanation:<\/b> Infrastructure capacity limits should be enforced deterministically rather than left to the language model. If the controller safely supports only 50 concurrent sessions, the automation platform should queue or batch the 500 requested operations and monitor failures, timeouts, and rate limits. Controlled concurrency improves throughput without overwhelming the controller or network devices. The AI may recommend a high-level plan, but execution systems should apply resource constraints, authorization, backoff, and operational policy. This separation allows organizations to use AI-generated automation while retaining predictable control over production infrastructure behavior.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q221. An Ansible playbook contains troubleshooting tasks that should run only when an engineer explicitly requests them during execution. Which Ansible feature is best suited to this requirement? Handlers 2. Tags 3. Registered variables 4. Inventory aliases Correct Answer: 2. Tags Explanation: Ansible […]<\/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\/18185"}],"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=18185"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18185\/revisions"}],"predecessor-version":[{"id":18186,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18185\/revisions\/18186"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18185"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18185"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18185"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}