{"id":19802,"date":"2026-09-23T07:45:22","date_gmt":"2026-09-23T07:45:22","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=19802"},"modified":"2026-09-23T07:45:22","modified_gmt":"2026-09-23T07:45:22","slug":"fortinet-fcp_fwf_ad-7-4-practice-test-questions-and-exam-dumps-part4-q61-80","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/fortinet-fcp_fwf_ad-7-4-practice-test-questions-and-exam-dumps-part4-q61-80\/","title":{"rendered":"Fortinet FCP_FWF_AD-7.4 Practice Test Questions and Exam Dumps Part4 Q61-80"},"content":{"rendered":"

View Full <\/b>Fortinet FCP_FWF_AD-7.4 Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 61.<\/b><\/p>\n

A FortiWeb administrator wants to ensure that traffic is forwarded only to backend servers that are actually serving the application correctly. Which configuration is MOST important?<\/b><\/p>\n

    \n
  1. <\/b> Application-aware server health checks<\/span><\/li>\n
  2. <\/b> IP reputation filtering<\/span><\/li>\n
  3. <\/b> Attack signature exceptions<\/span><\/li>\n
  4. <\/b> Administrator password aging<\/span><\/li>\n<\/ol>\n

    Correct Answer: 1. Application-aware server health checks<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    Application-aware health checks verify more than basic network connectivity. FortiWeb can send HTTP or HTTPS requests to a defined application resource and evaluate whether the response indicates that the service is functioning correctly. A server might accept TCP connections while the application itself is unavailable or returning errors, so simple reachability testing may not be sufficient. By using an application-aware check, FortiWeb can temporarily remove unhealthy members from load-balancing decisions and restore them when they recover. This helps maintain application availability and prevents clients from being sent to backend systems that are technically reachable but unable to provide the expected service.<\/span><\/p>\n

    Question 62.<\/b><\/p>\n

    A FortiWeb deployment uses several backend servers, and the administrator wants requests distributed across all healthy members. Which feature should be configured?<\/b><\/p>\n

      \n
    1. <\/b> URL rewriting<\/span><\/li>\n
    2. <\/b> Server load balancing<\/span><\/li>\n
    3. <\/b> Data leak prevention<\/span><\/li>\n
    4. <\/b> IP reputation<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2. Server load balancing<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      Server load balancing distributes incoming requests among multiple healthy backend servers. FortiWeb can use a configured algorithm to determine which server pool member receives each request. Combined with health checks, load balancing improves both scalability and availability because unavailable servers can be temporarily excluded from service. Session persistence may also be added when an application requires a user to remain associated with the same backend system. Data leak prevention and IP reputation are security controls, while load balancing is specifically designed to manage how client traffic is distributed among application servers.<\/span><\/p>\n

      Question 63.<\/b><\/p>\n

      A web application stores user session state locally on each backend server. What should the FortiWeb administrator configure to avoid session disruption?<\/b><\/p>\n

        \n
      1. <\/b> Attack signature exceptions<\/span><\/li>\n
      2. <\/b> HTTP method blocking<\/span><\/li>\n
      3. <\/b> Session persistence<\/span><\/li>\n
      4. <\/b> IP reputation filtering<\/span><\/li>\n<\/ol>\n

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

        Explanation:<\/b><\/p>\n

        When session state is stored locally on individual backend servers, users may need to continue reaching the same server for the duration of their session. Session persistence helps FortiWeb maintain that association so subsequent requests are routed consistently to the same backend member. Without persistence, load balancing could direct later requests to another server that does not contain the user’s session state, resulting in authentication problems or lost application context. The persistence method should match the application architecture and session behavior. This is primarily an application delivery function rather than an attack-detection capability.<\/span><\/p>\n

        Question 64.<\/b><\/p>\n

        What is a potential security benefit of configuring HTTPS between FortiWeb and the backend application server?<\/b><\/p>\n

          \n
        1. <\/b> It disables attack signatures<\/span><\/li>\n
        2. <\/b> It removes the need for certificates<\/span><\/li>\n
        3. <\/b> It prevents FortiWeb from inspecting requests<\/span><\/li>\n
        4. <\/b> It protects application data on the backend network segment**<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4. It protects application data on the backend network segment<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          Using HTTPS between FortiWeb and the backend server maintains encryption after FortiWeb has inspected the client request. This can be important when the internal network is not considered fully trusted or when compliance requirements require encryption in transit throughout the application path. FortiWeb can terminate the client TLS connection, inspect the decrypted HTTP content, and then establish a separate encrypted connection toward the backend. Administrators should configure certificate validation appropriately so encryption also provides meaningful server authentication. Backend HTTPS does not prevent FortiWeb from performing web application security inspection.<\/span><\/p>\n

          Question 65.<\/b><\/p>\n

          Which FortiWeb control can help stop requests that contain abnormally large HTTP headers?<\/b><\/p>\n

            \n
          1. <\/b> HTTP protocol constraints<\/span><\/li>\n
          2. <\/b> Server persistence<\/span><\/li>\n
          3. <\/b> Static routing<\/span><\/li>\n
          4. <\/b> Load balancing<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. HTTP protocol constraints<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            HTTP protocol constraints can enforce acceptable limits on request elements such as header lengths, request size, parameter count, methods, and other structural characteristics. Attackers may use malformed or oversized requests to consume resources, exploit parsing weaknesses, or bypass poorly implemented application controls. FortiWeb can reject requests that exceed configured limits before they reach the application. These settings should be tuned according to legitimate traffic because overly restrictive thresholds can generate false positives. Protocol validation complements signatures by checking whether requests conform to expected HTTP behavior.<\/span><\/p>\n

            Question 66.<\/b><\/p>\n

            An application never requires the HTTP DELETE method. What is the BEST FortiWeb configuration?<\/b><\/p>\n

              \n
            1. <\/b> Allow DELETE for compatibility<\/span><\/li>\n
            2. <\/b> Block DELETE if it is not part of legitimate application behavior<\/span><\/li>\n
            3. <\/b> Convert DELETE requests into GET requests<\/span><\/li>\n
            4. <\/b> Disable all HTTP methods<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. Block DELETE if it is not part of legitimate application behavior<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              Allowing only required HTTP methods reduces the application’s exposed functionality and follows the principle of least functionality. If DELETE is never used legitimately, there is little reason to allow clients to submit it. Restricting unused methods can reduce opportunities for abuse, especially in applications or APIs where improper method handling could expose sensitive operations. Administrators should first confirm normal application behavior so valid methods are not blocked accidentally. Method restrictions should be combined with proper authorization, signatures, behavioral controls, and secure application design.<\/span><\/p>\n

              Question 67.<\/b><\/p>\n

              A FortiWeb administrator wants to detect known cross-site scripting patterns in HTTP requests. Which feature should be enabled?<\/b><\/p>\n

                \n
              1. <\/b> Server health checks<\/span><\/li>\n
              2. <\/b> Static routing<\/span><\/li>\n
              3. <\/b> Web attack signatures<\/span><\/li>\n
              4. <\/b> Session persistence<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3. Web attack signatures<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                Web attack signatures inspect HTTP traffic for known malicious patterns associated with threats such as cross-site scripting, SQL injection, command injection, file inclusion, and other application-layer attacks. When a signature matches, FortiWeb can log, alert, or block the request according to policy. Signatures provide strong coverage against recognized attack techniques but should be used together with behavioral detection, protocol validation, access control, and secure coding. Health checks and persistence affect application delivery rather than malicious payload detection.<\/span><\/p>\n

                Question 68.<\/b><\/p>\n

                A legitimate API request triggers one FortiWeb attack signature because of a specific JSON parameter. What is the BEST response?<\/b><\/p>\n

                  \n
                1. <\/b> Disable all signatures<\/span><\/li>\n
                2. <\/b> Bypass FortiWeb for the API<\/span><\/li>\n
                3. <\/b> Allow all traffic from the client permanently<\/span><\/li>\n
                4. <\/b> Validate the request and create a narrowly scoped exception**<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 4. Validate the request and create a narrowly scoped exception<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  False positives should be resolved as narrowly as possible. The administrator should verify that the API request is legitimate, determine which parameter and signature caused the match, and create an exception limited to that specific context. This preserves protection for other parameters, URLs, clients, and application functions. Disabling an entire signature category or bypassing FortiWeb could expose the API to unrelated attacks. Exceptions should also be documented and reviewed periodically to determine whether they are still required as the application changes.<\/span><\/p>\n

                  Question 69.<\/b><\/p>\n

                  What is the PRIMARY reason to use behavioral or machine-learning protection in addition to attack signatures?<\/b><\/p>\n

                    \n
                  1. <\/b> To detect unusual application behavior that may not match known signatures<\/span><\/li>\n
                  2. <\/b> To eliminate the need for backend servers<\/span><\/li>\n
                  3. <\/b> To disable all security logs<\/span><\/li>\n
                  4. <\/b> To replace application authentication<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. To detect unusual application behavior that may not match known signatures<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    Attack signatures are effective against known patterns, but new or customized attacks may not match an existing rule exactly. Behavioral or machine-learning protection can establish a model of legitimate application activity and identify requests that deviate significantly from expected patterns. This adds another detection layer for emerging threats and abnormal behavior. The model should be trained and tuned using representative legitimate traffic before strict blocking is applied. Machine learning does not eliminate the need for signatures, authentication, secure coding, or operational monitoring; it complements those controls.<\/span><\/p>\n

                    Question 70.<\/b><\/p>\n

                    Why is a learning period useful before enabling strict machine-learning enforcement on FortiWeb?<\/b><\/p>\n

                      \n
                    1. <\/b> It makes TLS unnecessary<\/span><\/li>\n
                    2. <\/b> It helps establish legitimate application behavior and reduce false positives<\/span><\/li>\n
                    3. <\/b> It disables backend health checks<\/span><\/li>\n
                    4. <\/b> It prevents event logging<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. It helps establish legitimate application behavior and reduce false positives<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      A learning period allows FortiWeb to observe normal application traffic, including typical URLs, parameters, methods, request structures, and user behavior. If enforcement begins before the model has seen enough representative activity, legitimate but uncommon requests may appear suspicious and be blocked. Administrators should therefore monitor detections, verify learned patterns, and tune policies before moving to strict enforcement. Seasonal workflows, APIs, administrative tasks, and scheduled processes should be represented where possible. Proper learning improves accuracy without eliminating the need for other security controls.<\/span><\/p>\n

                      Question 71.<\/b><\/p>\n

                      A login page is receiving thousands of automated authentication attempts. Which FortiWeb capabilities are MOST relevant?<\/b><\/p>\n

                        \n
                      1. <\/b> Bot mitigation and rate limiting<\/span><\/li>\n
                      2. <\/b> Server persistence and load balancing only<\/span><\/li>\n
                      3. <\/b> Static routing and DNS forwarding<\/span><\/li>\n
                      4. <\/b> TLS offloading only<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. Bot mitigation and rate limiting<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        Automated login attacks such as credential stuffing and brute-force attempts often generate repeated authentication requests at a high rate. Bot mitigation can help identify automated clients, while rate limiting can reduce the number of requests allowed within a defined period. These controls should be tuned so legitimate users are not affected, particularly when many clients share a proxy or NAT address. They work best alongside strong authentication, multifactor authentication, account monitoring, and application-level lockout protections. Load balancing alone distributes the traffic but does not mitigate the attack.<\/span><\/p>\n

                        Question 72.<\/b><\/p>\n

                        An administrator wants to limit access to \/admin so that only internal management networks can reach it. Which feature is MOST suitable?<\/b><\/p>\n

                          \n
                        1. <\/b> Server health checking<\/span><\/li>\n
                        2. <\/b> Source-based URL access control<\/span><\/li>\n
                        3. <\/b> Session persistence<\/span><\/li>\n
                        4. <\/b> Signature update scheduling<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. Source-based URL access control<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          Source-based URL access control can restrict a sensitive path such as \/admin so it is reachable only from approved network ranges. This reduces exposure by preventing internet clients from even reaching the management interface. The control should complement strong authentication and authorization because source address alone is not a complete identity mechanism. Administrators should account for VPN users, remote administrators, and other legitimate access paths when defining allowed networks. Restricting access to sensitive URLs is a straightforward way to reduce the attack surface of a protected application.<\/span><\/p>\n

                          Question 73.<\/b><\/p>\n

                          A company wants to block access to an obsolete application path that is still present on the backend server. Which FortiWeb feature is MOST appropriate?<\/b><\/p>\n

                            \n
                          1. <\/b> Load balancing<\/span><\/li>\n
                          2. <\/b> Data leak prevention<\/span><\/li>\n
                          3. <\/b> URL access rules<\/span><\/li>\n
                          4. <\/b> IP reputation<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 3. URL access rules<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            URL access rules can define how requests to specific application paths are handled. If a legacy path should no longer be accessible, FortiWeb can deny requests to that path even while the backend resource still exists. This can reduce attack surface during application migration or cleanup. Administrators should confirm the path is truly obsolete before blocking it and monitor logs for attempted access. The underlying application should eventually remove unused functionality as well, because WAF controls complement rather than replace secure application maintenance.<\/span><\/p>\n

                            Question 74.<\/b><\/p>\n

                            A web application is accidentally returning payment card information in responses. Which FortiWeb capability is MOST relevant for detecting this exposure?<\/b><\/p>\n

                              \n
                            1. <\/b> Server persistence<\/span><\/li>\n
                            2. <\/b> Load balancing<\/span><\/li>\n
                            3. <\/b> Static routing<\/span><\/li>\n
                            4. <\/b> Data leak prevention**<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4. Data leak prevention<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              Data leak prevention can inspect web responses for patterns associated with sensitive information such as payment card data, personal identifiers, or other confidential content. Depending on configuration, FortiWeb can log, alert, mask, or take another action when protected information is detected. DLP should be tuned carefully because overly broad patterns can generate false positives. It should also complement proper application authorization, secure development, database controls, and data minimization. The best outcome is to prevent sensitive data from being exposed by the application in the first place.<\/span><\/p>\n

                              Question 75.<\/b><\/p>\n

                              An application accepts image uploads but should reject executable files. What should the FortiWeb administrator configure?<\/b><\/p>\n

                                \n
                              1. <\/b> File upload restrictions based on legitimate application requirements<\/span><\/li>\n
                              2. <\/b> A broader session persistence policy<\/span><\/li>\n
                              3. <\/b> Static routing<\/span><\/li>\n
                              4. <\/b> Disabled HTTP inspection<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. File upload restrictions based on legitimate application requirements<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                Upload controls should reflect what the application legitimately needs. If users only need to submit images, executable files and unrelated formats should be rejected. Administrators should also consider maximum file sizes and malware-related inspection where appropriate. The backend application should store uploaded files securely and should not execute user-supplied content. Restricting uploads reduces attack surface and limits opportunities for malicious file placement. Disabling inspection would remove valuable protection and is the opposite of the desired security outcome.<\/span><\/p>\n

                                Question 76.<\/b><\/p>\n

                                Why should FortiWeb administrators avoid relying only on source IP reputation when deciding whether traffic is malicious?<\/b><\/p>\n

                                  \n
                                1. <\/b> Reputation cannot be used with HTTPS<\/span><\/li>\n
                                2. <\/b> Source addresses can change, be shared, or provide incomplete context<\/span><\/li>\n
                                3. <\/b> IP reputation works only on backend servers<\/span><\/li>\n
                                4. <\/b> Reputation automatically disables signatures<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 2. Source addresses can change, be shared, or provide incomplete context<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  IP reputation is useful as an additional security signal, but it is not definitive. Attackers can move between addresses, legitimate users may share addresses through proxies or NAT, and cloud infrastructure can host both benign and malicious activity. FortiWeb should therefore combine reputation with request inspection, web attack signatures, behavioral analysis, bot detection, authentication, rate controls, and other contextual information. Layered security reduces the risk of both false positives and missed attacks that can occur when one indicator is treated as absolute.<\/span><\/p>\n

                                  Question 77.<\/b><\/p>\n

                                  An administrator notices repeated requests for sensitive files that do not exist on the application. What should the administrator use to investigate the pattern?<\/b><\/p>\n

                                    \n
                                  1. <\/b> FortiWeb attack and traffic logs<\/span><\/li>\n
                                  2. <\/b> Printer history<\/span><\/li>\n
                                  3. <\/b> Desktop configuration<\/span><\/li>\n
                                  4. <\/b> Physical server labels<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. FortiWeb attack and traffic logs<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    Logs can reveal source addresses, requested URLs, HTTP methods, matched rules, response codes, timestamps, and other information that helps administrators determine whether repeated requests represent scanning, reconnaissance, bot activity, or another attack pattern. Reviewing multiple related events can reveal trends that are not obvious from a single request. This information may support additional controls such as access rules, bot mitigation, rate limiting, or IP reputation actions. Effective logging and retention are essential for both operational troubleshooting and security investigation.<\/span><\/p>\n

                                    Question 78.<\/b><\/p>\n

                                    A protected application begins generating many false positives immediately after a major application update. What should the administrator do?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Disable FortiWeb permanently<\/span><\/li>\n
                                    2. <\/b> Review the changed URLs, parameters, request patterns, and relevant protection settings<\/span><\/li>\n
                                    3. <\/b> Remove all backend servers<\/span><\/li>\n
                                    4. <\/b> Disable all logging<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Review the changed URLs, parameters, request patterns, and relevant protection settings<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      Major application updates can introduce new URLs, parameters, APIs, request formats, methods, or workflow patterns. Existing FortiWeb policies may interpret these changes as abnormal or malicious. Administrators should review affected events and compare them with the new application behavior, then adjust signatures, exceptions, protocol constraints, or behavioral models as needed. Broadly disabling protection would create unnecessary exposure. Security policy should evolve with the application so enforcement remains accurate after significant changes.<\/span><\/p>\n

                                      Question 79.<\/b><\/p>\n

                                      A FortiWeb administrator wants to validate a new restrictive policy before applying it to all production users. What is the BEST approach?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Test or monitor the policy against representative traffic before broad enforcement<\/span><\/li>\n
                                      2. <\/b> Enable maximum blocking globally immediately<\/span><\/li>\n
                                      3. <\/b> Disable logging during deployment<\/span><\/li>\n
                                      4. <\/b> Bypass FortiWeb for production users<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. Test or monitor the policy against representative traffic before broad enforcement<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        A staged deployment allows administrators to identify false positives and compatibility problems before a restrictive policy affects the entire application population. Representative traffic should include common user workflows, APIs, administrative functions, uploads, unusual but legitimate requests, and other important application behavior. Logs and monitoring can then be reviewed to tune the configuration. After the policy behaves as expected, enforcement can be expanded. Immediate global blocking may cause unnecessary outages, while disabling logging removes the evidence required to understand problems.<\/span><\/p>\n

                                        Question 80.<\/b><\/p>\n

                                        Which statement BEST describes a mature FortiWeb security program?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Enable signatures once and never review them again<\/span><\/li>\n
                                        2. <\/b> Rely only on IP reputation<\/span><\/li>\n
                                        3. <\/b> Disable logs after deployment<\/span><\/li>\n
                                        4. <\/b> Combine application-aware deployment, layered protections, traffic monitoring, policy tuning, backend health checks, controlled exceptions, and continuous review**<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. Combine application-aware deployment, layered protections, traffic monitoring, policy tuning, backend health checks, controlled exceptions, and continuous review<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          A mature FortiWeb deployment combines security controls with ongoing application and operational knowledge. Administrators should maintain appropriate deployment architecture, TLS handling, backend pools, health checks, and load-balancing settings while applying layered controls such as signatures, behavioral protection, bot mitigation, protocol validation, access rules, file controls, and data protection. Logs should be reviewed for attacks and false positives, and exceptions should remain narrowly scoped and periodically reassessed. Because applications, APIs, certificates, backend infrastructure, and threats change continuously, FortiWeb security must be actively maintained rather than treated as a one-time configuration.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Fortinet FCP_FWF_AD-7.4 Exam Dumps and Practice Test Dumps   Question 61. A FortiWeb administrator wants to ensure that traffic is forwarded only to backend servers that are actually serving the application correctly. Which configuration is MOST important? Application-aware server health checks IP reputation filtering Attack signature exceptions Administrator password aging Correct Answer: 1. […]<\/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\/19802"}],"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=19802"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19802\/revisions"}],"predecessor-version":[{"id":19803,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19802\/revisions\/19803"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=19802"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=19802"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=19802"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}