{"id":18201,"date":"2026-09-22T06:00:43","date_gmt":"2026-09-22T06:00:43","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18201"},"modified":"2026-09-22T06:00:43","modified_gmt":"2026-09-22T06:00:43","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part20-q381-400","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part20-q381-400\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part20 Q381-400"},"content":{"rendered":"

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


\n<\/b>Q381. An Ansible playbook needs to create temporary host groups dynamically based on a device attribute discovered during execution. Which Ansible capability is most appropriate?<\/b><\/p>\n

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

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

    Explanation:<\/b> The Ansible <\/span>group_by<\/span> module can create dynamic inventory groups during playbook execution based on discovered facts or variables. For example, routers can be grouped according to software version, platform family, device role, or operational state and then targeted by later plays. This is useful when the required grouping is not known before execution. <\/span>notify<\/span> triggers handlers, <\/span>block<\/span> groups tasks for common handling, and <\/span>serial<\/span> controls batch size. Dynamic grouping can make large automation workflows more adaptable while still allowing later tasks to apply the correct configuration or validation logic to appropriate device categories.<\/span><\/p>\n

    Q382. A Terraform module receives an optional object whose attribute might not exist. The configuration should safely use a fallback value instead of failing evaluation. Which Terraform function is most suitable?<\/b><\/p>\n

      \n
    1. <\/b> file()<\/span>
      \n<\/span>2.<\/b> try()<\/span>
      \n<\/span>3.<\/b> timestamp()<\/span>
      \n<\/span>4.<\/b> toset()<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2. <\/b>try()<\/b><\/p>\n

      Explanation:<\/b> Terraform’s <\/span>try()<\/span> function evaluates expressions in order and returns the first one that does not produce an error. It is useful when a module accepts optional or variable-shaped input and needs a safe fallback if a particular attribute is unavailable. For example, <\/span>try(var.device.description, “Managed by Terraform”)<\/span> can use a default description when the optional attribute is missing. <\/span>file()<\/span> reads file content, <\/span>timestamp()<\/span> returns the current timestamp, and <\/span>toset()<\/span> converts a collection to a set. Fallback expressions should still be designed carefully so genuine configuration mistakes are not unintentionally hidden.<\/span><\/p>\n

      Q383. A RESTCONF client needs to retrieve a resource and its immediate children but should avoid receiving deeply nested descendant data. Which RESTCONF capability should the engineer investigate?<\/b><\/p>\n

        \n
      1. <\/b> HTTP CONNECT<\/span>
        \n<\/span>2.<\/b> Git sparse checkout<\/span>
        \n<\/span>3.<\/b> Supported <\/span>depth<\/span> query behavior<\/span>
        \n<\/span>4.<\/b> Terraform lifecycle rules<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Supported <\/b>depth<\/b> query behavior<\/b><\/p>\n

        Explanation:<\/b> RESTCONF defines query capabilities that can control the scope of returned modeled data. Where supported, the <\/span>depth<\/span> parameter can limit how deeply descendant nodes are included in the response. This can reduce response size when an automation workflow needs a parent resource and only a limited amount of nested data. Engineers should verify the target device’s implementation and use precise resource paths as well. Excessively broad queries can waste bandwidth and processing resources when scaled across many devices. Git and Terraform features do not control RESTCONF response depth, while HTTP CONNECT serves a completely different purpose.<\/span><\/p>\n

        Q384. A Python automation script counts how many interfaces belong to each operational state. The engineer wants missing dictionary keys to start automatically at zero. Which data structure is especially convenient?<\/b><\/p>\n

          \n
        1. <\/b> bytes<\/span>
          \n<\/span>2.<\/b> tuple<\/span>
          \n<\/span>3.<\/b> frozenset<\/span>
          \n<\/span>4.<\/b> collections.defaultdict<\/span><\/li>\n<\/ol>\n

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

          Explanation:<\/b> A <\/span>defaultdict<\/span> can automatically create a default value when code accesses a missing key. For counting interface states, a <\/span>defaultdict(int)<\/span> initializes missing counters to zero, allowing code to increment values directly without checking whether each key already exists. This can make aggregation logic shorter and clearer. A normal dictionary can accomplish the same task with methods such as <\/span>get()<\/span>, and <\/span>collections.Counter<\/span> is also useful for counting scenarios. Choosing the appropriate Python structure simplifies automation code and reduces unnecessary conditional logic when processing large device inventories or telemetry datasets.<\/span><\/p>\n

          Q385. A network API returns HTTP 409 Conflict when automation attempts to create a resource. What should the client investigate first?<\/b><\/p>\n

            \n
          1. <\/b> Whether the requested operation conflicts with the current resource state or an existing object<\/span>
            \n<\/span>2.<\/b> Whether the TLS certificate has exactly six months remaining<\/span>
            \n<\/span>3.<\/b> Whether the response should be converted to XML<\/span>
            \n<\/span>4.<\/b> Whether the Git repository has untracked files<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Whether the requested operation conflicts with the current resource state or an existing object<\/b><\/p>\n

            Explanation:<\/b> HTTP 409 indicates that the server cannot complete the request because it conflicts with the current state of the target resource or system. For example, automation may be attempting to create an object whose identifier already exists, or a state transition may be incompatible with the resource’s current condition. The client should inspect the API’s error details and determine whether it should retrieve current state, choose a different identifier, or alter the requested operation. A 409 is not primarily a TLS or source-control issue, and blindly retrying the identical request may simply reproduce the same conflict.<\/span><\/p>\n

            Q386. An engineer needs to determine which commit and author last changed each line of a network automation file. Which Git command is most appropriate?<\/b><\/p>\n

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

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

              Explanation:<\/b> git blame<\/span> annotates lines in a file with information about the commit and author responsible for the most recent change to each line. It can help engineers investigate why a network automation statement was introduced, identify the relevant commit for further review, or find contextual history surrounding a configuration rule. It should be used as a diagnostic tool rather than as a substitute for collaborative review. <\/span>git stash<\/span> stores temporary local changes, <\/span>git clean<\/span> removes untracked files, and <\/span>git init<\/span> initializes a repository. Version history is especially valuable when Infrastructure as Code directly controls production behavior.<\/span><\/p>\n

              Q387. A GitLab pipeline includes a noncritical documentation job that should be reported if it fails but must not prevent network validation and deployment jobs from continuing. Which job behavior is most appropriate?<\/b><\/p>\n

                \n
              1. <\/b> Delete the job entirely<\/span>
                \n<\/span>2.<\/b> Make every later job ignore all failures<\/span>
                \n<\/span>3.<\/b> Configure that specific job as allowed to fail<\/span>
                \n<\/span>4.<\/b> Convert it into a production deployment job<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3. Configure that specific job as allowed to fail<\/b><\/p>\n

                Explanation:<\/b> CI\/CD systems can distinguish between required jobs and nonblocking informational jobs. Marking a specific noncritical job as allowed to fail lets the pipeline report the failure while continuing required stages. This should be used selectively; security checks, syntax validation, prevalidation, deployment gates, and post-validation should remain blocking when their success is required for safe network changes. Broadly ignoring all failures would undermine the pipeline’s control function. Pipeline design should clearly identify which results are advisory and which results constitute mandatory quality or operational gates.<\/span><\/p>\n

                Q388. A CML integration test modifies device configurations extensively. The team wants every new test run to start from the same known lab state. Which strategy best supports this?<\/b><\/p>\n

                  \n
                1. <\/b> Allow previous test changes to accumulate indefinitely<\/span>
                  \n<\/span>2.<\/b> Ask engineers to remember all prior changes<\/span>
                  \n<\/span>3.<\/b> Skip initialization to reduce pipeline time<\/span>
                  \n<\/span>4.<\/b> Recreate or restore the topology from a controlled baseline before each test<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 4. Recreate or restore the topology from a controlled baseline before each test<\/b><\/p>\n

                  Explanation:<\/b> Integration tests are most reliable when they begin from a known state. Recreating the CML topology or restoring an approved baseline removes configuration drift introduced by previous tests and makes failures reproducible. The baseline definition should be version controlled and associated with the automation being tested. Reusing an unknown state can cause one test run to influence another and produce intermittent failures. After initialization, the pipeline can apply the candidate change, run deterministic validation, preserve useful evidence, and clean up. Repeatability is a core requirement for trustworthy automated network testing.<\/span><\/p>\n

                  Q389. A model-driven telemetry system should report an analog metric only when the value changes by more than a meaningful threshold, reducing insignificant updates. Which concept best describes this behavior?<\/b><\/p>\n

                    \n
                  1. <\/b> Deadband filtering<\/span>
                    \n<\/span>2.<\/b> Git rebasing<\/span>
                    \n<\/span>3.<\/b> Terraform import<\/span>
                    \n<\/span>4.<\/b> Certificate pinning<\/span><\/li>\n<\/ol>\n

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

                    Explanation:<\/b> Deadband filtering suppresses telemetry updates when changes are smaller than a defined threshold. This can reduce unnecessary traffic and storage for noisy metrics that fluctuate slightly but do not represent meaningful operational changes. For example, an automation platform may care about significant temperature or utilization changes rather than every tiny variation. Thresholds must be selected carefully because an overly large deadband can hide important trends. Telemetry architecture should balance update frequency, fidelity, collector capacity, storage, and operational requirements. Deadband behavior is unrelated to source-control or Infrastructure as Code operations.<\/span><\/p>\n

                    Q390. An operations team wants to measure how long a network automation job takes from its initial request through validation, device changes, and final completion. Which observability metric is most appropriate?<\/b><\/p>\n

                      \n
                    1. <\/b> Number of Git branches<\/span>
                      \n<\/span>2.<\/b> End-to-end workflow latency<\/span>
                      \n<\/span>3.<\/b> Certificate key length<\/span>
                      \n<\/span>4.<\/b> Number of YAML comments<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. End-to-end workflow latency<\/b><\/p>\n

                      Explanation:<\/b> End-to-end workflow latency measures the elapsed time from the beginning of an automation request to its final completion. Breaking the measurement into stages can reveal whether delays occur in API calls, approvals, device configuration, telemetry checks, or post-validation. Tracking latency over time also helps detect performance regressions after application or infrastructure changes. A complete operational view should combine latency with success rate, error rate, throughput, and resource utilization. Good observability allows teams to distinguish a correct but slow automation system from one that meets both functional and operational performance requirements.<\/span><\/p>\n

                      Q391. A pyATS test should mark a validation section as not applicable on routers that do not support the tested feature. What is the best testing behavior?<\/b><\/p>\n

                        \n
                      1. <\/b> Mark every unsupported router as failed<\/span>
                        \n<\/span>2.<\/b> Delete the router from inventory permanently<\/span>
                        \n<\/span>3.<\/b> Skip the test for devices where the prerequisite feature is not applicable<\/span>
                        \n<\/span>4.<\/b> Report success without recording that the test was not executed<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. Skip the test for devices where the prerequisite feature is not applicable<\/b><\/p>\n

                        Explanation:<\/b> A test should distinguish genuine failure from a condition that does not apply to a particular platform or device role. If a feature is intentionally unsupported or irrelevant, the test can be skipped with an appropriate reason rather than reported as failed or falsely reported as passed. This produces more accurate pipeline results and helps operators understand test coverage. Applicability criteria should come from authoritative device metadata or platform capabilities, not arbitrary assumptions. Good automated validation records whether a test passed, failed, errored, or was skipped and provides enough context to explain that result.<\/span><\/p>\n

                        Q392. A Dockerfile installs compilers and package-building tools that are needed only while building the automation application. What is the best method to keep those tools out of the production image?<\/b><\/p>\n

                          \n
                        1. <\/b> Run the production container in privileged mode<\/span>
                          \n<\/span>2.<\/b> Use a multi-stage Docker build<\/span>
                          \n<\/span>3.<\/b> Publish additional container ports<\/span>
                          \n<\/span>4.<\/b> Store the compiler inside a persistent volume<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. Use a multi-stage Docker build<\/b><\/p>\n

                          Explanation:<\/b> A multi-stage Docker build separates build-time dependencies from the final runtime image. Compilation tools and development packages can exist in an earlier stage, while only the resulting application artifacts and required runtime libraries are copied into the final stage. This reduces image size and may reduce attack surface by removing unnecessary software. It also supports cleaner, more reproducible container builds. Production images should still use trusted base images, vulnerability scanning, non-root execution where practical, secure secrets handling, and controlled dependencies. Multi-stage builds solve packaging concerns rather than runtime authorization.<\/span><\/p>\n

                          Q393. An automation client wants to detect a potentially revoked TLS certificate without downloading a full certificate revocation list. Which mechanism can provide certificate status dynamically?<\/b><\/p>\n

                            \n
                          1. <\/b> Git signing<\/span>
                            \n<\/span>2.<\/b> Terraform validation<\/span>
                            \n<\/span>3.<\/b> Docker image digest<\/span>
                            \n<\/span>4.<\/b> OCSP<\/span><\/li>\n<\/ol>\n

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

                            Explanation:<\/b> The Online Certificate Status Protocol allows a client or related TLS component to obtain revocation status for a particular certificate from an OCSP responder. This can provide more focused status checking than downloading an entire certificate revocation list. Actual client behavior depends on platform configuration and PKI policy, and some environments also use OCSP stapling to improve privacy and performance. Revocation is important when a certificate or private key is compromised before normal expiration. Certificate lifecycle management therefore includes issuance, trust-chain validation, renewal, revocation, and protection of associated private keys.<\/span><\/p>\n

                            Q394. A team uses an external generative AI service to help troubleshoot network logs. Before logs are submitted, what control best reduces accidental disclosure of confidential information?<\/b><\/p>\n

                              \n
                            1. <\/b> Classify and redact sensitive fields before sending the data to the AI service<\/span>
                              \n<\/span>2.<\/b> Include every password to improve context<\/span>
                              \n<\/span>3.<\/b> Disable organizational data-handling policies<\/span>
                              \n<\/span>4.<\/b> Make all internal logs publicly accessible first<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. Classify and redact sensitive fields before sending the data to the AI service<\/b><\/p>\n

                              Explanation:<\/b> Network logs can contain internal addresses, usernames, tokens, customer information, configuration details, or other sensitive data. Before sending data to an external AI service, the application should identify information that is not appropriate for disclosure and redact, tokenize, minimize, or otherwise protect it according to organizational policy. The team should also review provider retention, training, contractual, and access-control terms. Redaction does not eliminate every AI risk, but it helps enforce data-minimization principles and reduces the consequences of unnecessary disclosure while preserving enough operational context for useful troubleshooting.<\/span><\/p>\n

                              Q395. An engineer wants an LLM to generate configuration in a specific syntax and provides two correct example input-output pairs in the prompt. Which prompting technique is being used?<\/b><\/p>\n

                                \n
                              1. <\/b> Unsupervised model training<\/span>
                                \n<\/span>2.<\/b> Few-shot prompting<\/span>
                                \n<\/span>3.<\/b> Certificate enrollment<\/span>
                                \n<\/span>4.<\/b> Terraform state migration<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. Few-shot prompting<\/b><\/p>\n

                                Explanation:<\/b> Few-shot prompting provides the model with a small number of examples demonstrating the desired input-output relationship or response format. This can improve consistency when the model must generate structured network configuration, classify operational events, or follow a specialized convention. The examples should be representative and free of confidential information unless the AI environment is approved to process it. Few-shot prompting does not guarantee correctness; generated configuration still requires schema validation, policy checking, testing, and authorization. Prompt design is one component of the broader AI automation architecture rather than an infrastructure safety boundary.<\/span><\/p>\n

                                Q396. A retrieval system must answer queries that include exact interface identifiers such as <\/b>GigabitEthernet0\/0\/1<\/b> as well as conceptual questions about routing design. Which retrieval approach may improve coverage?<\/b><\/p>\n

                                  \n
                                1. <\/b> Use only random document selection<\/span>
                                  \n<\/span>2.<\/b> Remove all exact identifiers from the index<\/span>
                                  \n<\/span>3.<\/b> Combine keyword-based and semantic retrieval<\/span>
                                  \n<\/span>4.<\/b> Use semantic search but disable metadata entirely<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Combine keyword-based and semantic retrieval<\/b><\/p>\n

                                  Explanation:<\/b> Semantic vector retrieval is effective for conceptual similarity, while lexical or keyword search can be stronger for exact identifiers, command names, error codes, and interface labels. A hybrid retrieval system combines both approaches and can improve recall across diverse network questions. Results can then be reranked and filtered according to authorization, freshness, and source authority. Hybrid retrieval does not guarantee a correct final answer, but it gives the model better candidate evidence. Network documentation often contains both conceptual prose and highly specific technical strings, making a mixed retrieval strategy valuable.<\/span><\/p>\n

                                  Q397. An MCP-enabled AI agent can read router state and propose changes, but write tools require a separate approval token generated only after an engineer reviews the plan. What security benefit does this provide?<\/b><\/p>\n

                                    \n
                                  1. <\/b> It makes the LLM deterministic<\/span>
                                    \n<\/span>2.<\/b> It removes the need for authentication<\/span>
                                    \n<\/span>3.<\/b> It allows retrieved documents to bypass policy<\/span>
                                    \n<\/span>4.<\/b> It creates a technical approval boundary before privileged execution<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 4. It creates a technical approval boundary before privileged execution<\/b><\/p>\n

                                    Explanation:<\/b> Requiring a separate approval token means that conversational reasoning alone cannot authorize a production-changing tool call. The AI can gather data and prepare a plan, but the privileged execution path becomes available only after an authorized review process generates the required capability. This provides a stronger control than simply asking the model to wait for approval in natural language. The backend should verify the token’s scope, target, expiration, and relationship to the approved change. Audit logs should record both the approval and execution so production modifications remain attributable and reviewable.<\/span><\/p>\n

                                    Q398. An MCP tool returns 50,000 interface records, but the agent normally needs fewer than 20. Which API design best improves efficiency?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Always return all records so the model can decide<\/span>
                                      \n<\/span>2.<\/b> Support server-side filtering, result limits, and pagination<\/span>
                                      \n<\/span>3.<\/b> Disable interface queries<\/span>
                                      \n<\/span>4.<\/b> Convert all records into one long unstructured string<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Support server-side filtering, result limits, and pagination<\/b><\/p>\n

                                      Explanation:<\/b> Tool interfaces should allow callers to request only the data they need. Server-side filters, pagination, and explicit result limits reduce controller load, network transfer, MCP server memory consumption, and LLM context usage. The server can also enforce maximum limits even when the model requests an excessive result set. Efficient tool design improves both reliability and security because resource consumption is bounded deterministically. The model should not be expected to receive massive datasets and discard most of them afterward. Filtering should also respect authorization so broad queries cannot expose unrelated resources.<\/span><\/p>\n

                                      Q399. An AI fault detector raises 100 alarms, and 80 of those alarms correspond to real faults. Which evaluation metric describes the proportion of raised alarms that were correct?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Recall<\/span>
                                        \n<\/span>2.<\/b> Latency<\/span>
                                        \n<\/span>3.<\/b> Precision<\/span>
                                        \n<\/span>4.<\/b> Availability<\/span><\/li>\n<\/ol>\n

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

                                        Explanation:<\/b> Precision measures the proportion of positive predictions that are actually correct. In this scenario, 80 of 100 alarms represent real faults, giving a precision of 80 percent. Recall asks a different question: what proportion of all real faults the system successfully detected. Both metrics are useful because a system can achieve high recall by raising many alarms while suffering poor precision, or high precision while missing many real conditions. Network AI evaluation should choose metrics according to operational consequences and should not rely only on a single aggregate accuracy number when different error types have different costs.<\/span><\/p>\n

                                        Q400. An AI-assisted automation change passes all prechecks but produces unexpected production behavior after deployment. Which workflow characteristic is most important for limiting impact?<\/b><\/p>\n

                                          \n
                                        1. <\/b> A tested rollback procedure triggered when post-validation fails<\/span>
                                          \n<\/span>2.<\/b> Removing previous known-good configurations<\/span>
                                          \n<\/span>3.<\/b> Disabling post-change monitoring<\/span>
                                          \n<\/span>4.<\/b> Preventing operators from stopping automation<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 1. A tested rollback procedure triggered when post-validation fails<\/b><\/p>\n

                                          Explanation:<\/b> Even thoroughly validated changes can behave unexpectedly in production because simulations and prechecks cannot reproduce every dependency. Post-validation should determine whether the actual network reached the expected state. If critical checks fail, the automation should have a tested rollback strategy capable of restoring a known-good configuration or otherwise containing the impact. Rollback behavior must itself be tested because an unverified recovery process can compound an outage. AI-generated changes should follow the same disciplined change lifecycle as other automation: plan, validate, approve as needed, deploy, verify, and recover predictably when outcomes differ from expectations.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q381. An Ansible playbook needs to create temporary host groups dynamically based on a device attribute discovered during execution. Which Ansible capability is most appropriate? group_by 2. notify 3. block 4. serial Correct Answer: 1. group_by Explanation: The Ansible group_by module can create […]<\/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\/18201"}],"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=18201"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18201\/revisions"}],"predecessor-version":[{"id":18202,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18201\/revisions\/18202"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18201"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18201"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18201"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}