{"id":20716,"date":"2026-09-24T06:58:05","date_gmt":"2026-09-24T06:58:05","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=20716"},"modified":"2026-09-24T06:58:05","modified_gmt":"2026-09-24T06:58:05","slug":"appian-acd201-practice-test-questions-and-exam-dumps-part12-q221-240","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/appian-acd201-practice-test-questions-and-exam-dumps-part12-q221-240\/","title":{"rendered":"Appian ACD201 Practice Test Questions and Exam Dumps Part12 Q221-240"},"content":{"rendered":"

View Full <\/b>Appian ACD201 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Question 221. A developer needs to safely retrieve the firstName field from a CDT variable that might be null. Which approach is recommended?<\/b><\/p>\n

    \n
  1. <\/b> Convert the CDT to a document before reading the field<\/span><\/li>\n
  2. <\/b> Always use direct dot notation regardless of null values<\/span><\/li>\n
  3. <\/b> Use index() with an appropriate default value<\/span><\/li>\n
  4. <\/b> Store the CDT in an application constant first<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3. Use index() with an appropriate default value<\/b><\/p>\n

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

    Appian supports several ways to access fields in complex values, including dot notation, bracket notation, and the <\/span>index()<\/span> function. When a CDT value itself might be null or the requested field might not be available, <\/span>index()<\/span> is particularly useful because the developer can provide a default value that is returned instead of relying on direct field access. For example, <\/span>index(pv!person, “firstName”, “”)<\/span> can return an empty string when no usable value is available. This makes expressions more defensive and reduces avoidable evaluation errors in interfaces, rules, and process logic that work with optional structured data.<\/span><\/p>\n

    Question 222. What is the purpose of the fn! domain in an Appian expression?<\/b><\/p>\n

      \n
    1. <\/b> To explicitly reference an Appian built-in function<\/span><\/li>\n
    2. <\/b> To reference a process variable<\/span><\/li>\n
    3. <\/b> To reference an expression rule<\/span><\/li>\n
    4. <\/b> To reference an application constant<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. To explicitly reference an Appian built-in function<\/b><\/p>\n

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

      Appian expressions use domains to indicate what kind of object or value is being referenced. Built-in Appian functions can be referenced using the <\/span>fn!<\/span> domain, although it is often optional when calling standard functions. Other domains serve different purposes: <\/span>rule!<\/span> references reusable expression or interface rules, <\/span>cons!<\/span> references constants, <\/span>pv!<\/span> references process variables, <\/span>ri!<\/span> references rule inputs, and <\/span>local!<\/span> references local variables. Understanding these domains makes complex expressions easier to read and troubleshoot because developers can quickly identify whether a value comes from the platform, the application design, the current process, or the current expression context.<\/span><\/p>\n

      Question 223. What does the null() function return when called without a type argument?<\/b><\/p>\n

        \n
      1. <\/b> An empty text string<\/span><\/li>\n
      2. <\/b> The Boolean value false<\/span><\/li>\n
      3. <\/b> The number zero<\/span><\/li>\n
      4. <\/b> A value of type Null<\/span><\/li>\n<\/ol>\n

        Correct Answer: 4. A value of type Null<\/b><\/p>\n

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

        Calling <\/span>null()<\/span> without a type argument returns a null value whose type is Null. Appian also allows a type to be passed to <\/span>null()<\/span> when a typed null value is required. For example, <\/span>null(type!Integer)<\/span> returns a null value typed as Number (Integer). Typed nulls can be useful when an expression’s return-type consistency matters or when values are passed into strongly typed application structures. Developers should distinguish null from an empty string, zero, or false because those are actual values with different meanings. Correct null handling is important for reliable filtering, conditional logic, database writes, and interface behavior.<\/span><\/p>\n

        Question 224. A process expression attempts to execute a!save() directly in a process-model node input. What is the likely problem?<\/b><\/p>\n

          \n
        1. <\/b> a!save() can only work with database fields<\/span><\/li>\n
        2. <\/b> a!save() is not supported as a general process-model expression function and is intended for saveInto contexts<\/span><\/li>\n
        3. <\/b> a!save() requires every process to use autoscale<\/span><\/li>\n
        4. <\/b> a!save() can be used only by system administrators<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2. a!save() is not supported as a general process-model expression function and is intended for saveInto contexts<\/b><\/p>\n

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

          a!save()<\/span> is designed for save behavior in supported interface-component and smart-service function contexts rather than as a general expression that can be evaluated anywhere in a process model. Appian’s process troubleshooting guidance identifies unsupported functions, including <\/span>a!save()<\/span> and certain smart-service functions, as possible causes of process expression evaluation errors. In a process node, developers should configure node inputs and outputs using normal expressions and explicit process-variable mappings. Understanding feature compatibility is important because an expression can be syntactically valid yet still fail when evaluated in a context where one of its functions is not supported.<\/span><\/p>\n

          Question 225. What is a major difference between exporting a process report to CSV and exporting it to Excel?<\/b><\/p>\n

            \n
          1. <\/b> CSV exports cannot contain any process-report data<\/span><\/li>\n
          2. <\/b> Excel exports are limited to one record<\/span><\/li>\n
          3. <\/b> CSV exports automatically create process variables instead of documents<\/span><\/li>\n
          4. <\/b> CSV output leaves raw values largely unformatted, while Excel is more appropriate when formatted output is required<\/span><\/li>\n<\/ol>\n

            Correct Answer: 4. CSV output leaves raw values largely unformatted, while Excel is more appropriate when formatted output is required<\/b><\/p>\n

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

            The Export Process Report to CSV smart service is intended to create CSV documents containing process-report data. Appian notes that CSV output intentionally leaves raw values and data unformatted. When formatted values are required, developers should consider the corresponding Excel export capability instead. The choice therefore depends partly on how the exported information will be consumed. CSV is particularly useful when information will be imported into another data-processing system, while Excel may provide a more user-friendly format for human consumption. Both approaches allow Appian process-report information to be delivered outside the application’s interactive reporting experience.<\/span><\/p>\n

            Question 226. A process-report CSV export needs to return only records that satisfy two conditions. How should the Filters input be configured?<\/b><\/p>\n

              \n
            1. <\/b> Use an appropriate logical expression or a list of query filters<\/span><\/li>\n
            2. <\/b> Add two unrelated process start events<\/span><\/li>\n
            3. <\/b> Configure the conditions as email recipients<\/span><\/li>\n
            4. <\/b> Put the conditions into the CSV filename<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1. Use an appropriate logical expression or a list of query filters<\/b><\/p>\n

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

              The Export Process Report to CSV smart service allows developers to filter the queried process-report data before generating the document. Multiple conditions can be represented using an <\/span>a!queryLogicalExpression()<\/span> or by supplying a list of query filters. When a list of filters is supplied, Appian combines them using AND behavior. Developers should select the form that most clearly represents the required filtering logic, especially when nested AND and OR conditions are involved. Applying filtering as part of the export is preferable to exporting a much larger report and attempting to remove unwanted information later because it limits the data included in the generated document.<\/span><\/p>\n

              Question 227. What is the maximum number of rows supported by the Export Process Report to CSV smart service?<\/b><\/p>\n

                \n
              1. <\/b> 1,000 rows<\/span><\/li>\n
              2. <\/b> 50,000 rows<\/span><\/li>\n
              3. <\/b> 10,000 rows<\/span><\/li>\n
              4. <\/b> There is no row limit<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3. 10,000 rows<\/b><\/p>\n

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

                Appian documents a maximum export limit of 10,000 rows for the Export Process Report to CSV smart service, along with a maximum of 50 columns. These limits exist for performance reasons and should influence reporting design when process data volumes are large. If users require substantially more information, developers should evaluate whether another reporting or data-extraction architecture would be more appropriate instead of attempting to force an oversized result into one process-report export. Senior developers should consider volume requirements during design because an implementation that works with small test datasets can fail to meet expectations when production process data grows significantly.<\/span><\/p>\n

                Question 228. What does the Export Process Report to CSV smart service return after successfully creating an export?<\/b><\/p>\n

                  \n
                1. <\/b> A security group<\/span><\/li>\n
                2. <\/b> A Document representing the generated CSV file<\/span><\/li>\n
                3. <\/b> A process model object<\/span><\/li>\n
                4. <\/b> A connected system<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2. A Document representing the generated CSV file<\/b><\/p>\n

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

                  The Export Process Report to CSV smart service generates a CSV file in Appian document management and returns the generated document as its output. The developer can specify information such as the document name, description, destination folder, delimiter, and whether a header should be included. The returned Document identifier can then be saved to a process variable and used later in the workflow\u2014for example, as an email attachment or a downloadable document. Treating the result as an Appian document allows the normal document-security and document-management mechanisms to apply to the generated output.<\/span><\/p>\n

                  Question 229. What happens when an existing document is supplied to the Document to Update input of a process-report CSV export?<\/b><\/p>\n

                    \n
                  1. <\/b> New exported content can be appended and a new version of the document is created<\/span><\/li>\n
                  2. <\/b> The existing document is permanently deleted first<\/span><\/li>\n
                  3. <\/b> Appian converts the document into a process model<\/span><\/li>\n
                  4. <\/b> The export automatically changes the file to PDF<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. New exported content can be appended and a new version of the document is created<\/b><\/p>\n

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

                    The process-report CSV export can update an existing document instead of always creating a new one. When the <\/span>Document to Update<\/span> parameter is supplied, Appian appends the new exported contents to that document and creates a new version. This can be useful when a workflow needs to gather data from more than one process report or produce a cumulative output through several export operations. Developers should manage headers, delimiters, filtering, and output structure carefully so the resulting combined document remains usable. Appian document versioning also means the earlier version is retained rather than being silently destroyed.<\/span><\/p>\n

                    Question 230. Which statement about the Send E-Mail smart service is correct?<\/b><\/p>\n

                      \n
                    1. <\/b> It can run only as an attended user task<\/span><\/li>\n
                    2. <\/b> It cannot send attachments<\/span><\/li>\n
                    3. <\/b> It supports only plain text messages<\/span><\/li>\n
                    4. <\/b> It is an unattended smart service that supports normal text as well as HTML email bodies<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 4. It is an unattended smart service that supports normal text as well as HTML email bodies<\/b><\/p>\n

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

                      The Send E-Mail smart service is an unattended process activity used to send messages to one or more recipients. Its body supports both ordinary text and HTML, allowing developers to create formatted notifications when necessary. The activity also supports options for sender information, recipients, Cc, Bcc, attachments, Reply-To addresses, subject lines, and priority. Because it is unattended, the process does not require a user to manually complete the node before the email is sent. Developers should still keep email content, recipient selection, security, and sensitive-data handling in mind when using automated notification capabilities in enterprise processes.<\/span><\/p>\n

                      Question 231. Why should sensitive confidential information generally not be sent directly through the Send E-Mail smart service without additional safeguards?<\/b><\/p>\n

                        \n
                      1. <\/b> Appian automatically publishes every email publicly<\/span><\/li>\n
                      2. <\/b> Data transferred by the Send E-Mail smart service is not encrypted by the smart service itself<\/span><\/li>\n
                      3. <\/b> Emails can only be sent to external recipients<\/span><\/li>\n
                      4. <\/b> Every email is stored permanently in a process variable<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. Data transferred by the Send E-Mail smart service is not encrypted by the smart service itself<\/b><\/p>\n

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

                        Appian’s documentation states that data transferred using the Send E-Mail smart service is not encrypted and specifically cautions against exchanging unencrypted sensitive or confidential information through this mechanism. Application teams are responsible for designing appropriate security around their email usage. A safer pattern may be to send a notification that directs an authorized user back to secured information within Appian rather than including confidential business data directly in the email message. Senior developers should consider the sensitivity of email bodies, attachments, recipients, and external mail infrastructure whenever automated processes send business information outside the Appian user interface.<\/span><\/p>\n

                        Question 232. A process-generated email should allow replies to go to an address different from the From address. Which Send E-Mail configuration should be used?<\/b><\/p>\n

                          \n
                        1. <\/b> Priority<\/span><\/li>\n
                        2. <\/b> Bcc<\/span><\/li>\n
                        3. <\/b> Reply To<\/span><\/li>\n
                        4. <\/b> Process Report Context<\/span><\/li>\n<\/ol>\n

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

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

                          The Reply To setting lets a developer specify the email address that a mail client should use when the recipient selects Reply. This is useful when the visible sender address should remain associated with a process or application identity, but replies need to reach a monitored mailbox or support team. For example, a process-generated sender address may not itself accept incoming mail. Configuring Reply To avoids confusing users or losing responses while preserving the desired From address. This setting is different from Cc or Bcc, which add recipients, and Priority, which describes the importance of the outgoing email.<\/span><\/p>\n

                          Question 233. A process email must send a file already stored in Appian document management. What should the developer configure?<\/b><\/p>\n

                            \n
                          1. <\/b> Add the Appian document to the email’s Attachments configuration<\/span><\/li>\n
                          2. <\/b> Convert the document into a security group<\/span><\/li>\n
                          3. <\/b> Store the complete binary file in the Subject field<\/span><\/li>\n
                          4. <\/b> Replace the Send E-Mail node with an XOR gateway<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Add the Appian document to the email’s Attachments configuration<\/b><\/p>\n

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

                            The Send E-Mail smart service supports attachments from Appian document management. A developer can select a stored document directly or use an expression that resolves to the required document. This works well with document-generation and export smart services because the generated document identifier can first be saved into a process variable and then supplied as an email attachment in a later node. Developers should verify that the document contains appropriate information for the recipients and that sending it outside the secured Appian environment is consistent with organizational security requirements. Emailing a document changes the security context in which its contents may be distributed.<\/span><\/p>\n

                            Question 234. What is the PRIMARY purpose of a Text Doc From Template smart service?<\/b><\/p>\n

                              \n
                            1. <\/b> To start an external REST API request<\/span><\/li>\n
                            2. <\/b> To create or update a text document using a template and process data<\/span><\/li>\n
                            3. <\/b> To convert all database records into process variables<\/span><\/li>\n
                            4. <\/b> To manage site security<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. To create or update a text document using a template and process data<\/b><\/p>\n

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

                              The Text Doc From Template smart service is part of Appian’s document-generation capabilities. It allows a process to create a new text document or update an existing document using a predefined template and values available from process data. This pattern is useful when applications need standardized text output such as confirmations, data extracts, notices, or other generated text artifacts. Templates containing Unicode characters should use UTF-8 encoding so the characters are represented correctly. For richer formats, Appian also provides other document-generation smart services designed for formats such as Word, HTML, OpenOffice Writer, and PDF.<\/span><\/p>\n

                              Question 235. Why should a template file containing Unicode characters be encoded as UTF-8 when used by the Text Doc From Template smart service?<\/b><\/p>\n

                                \n
                              1. <\/b> To automatically convert the document into Excel<\/span><\/li>\n
                              2. <\/b> To reduce every generated file to one line<\/span><\/li>\n
                              3. <\/b> To disable document security<\/span><\/li>\n
                              4. <\/b> To ensure Unicode characters are represented correctly in the generated document<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 4. To ensure Unicode characters are represented correctly in the generated document<\/b><\/p>\n

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

                                Appian specifies that template files used by the Text Doc From Template smart service should be encoded in UTF-8 when Unicode characters appear in the document. UTF-8 supports a broad range of characters from many languages and symbol sets. If an incompatible encoding is used, special characters may appear corrupted, be replaced with incorrect symbols, or fail to render as intended. This is particularly important for international applications that generate documents containing accented characters, non-Latin alphabets, or other multilingual content. Developers should therefore treat file encoding as part of document-generation quality assurance rather than merely a technical detail.<\/span><\/p>\n

                                Question 236. What is the Query Database smart service primarily capable of doing?<\/b><\/p>\n

                                  \n
                                1. <\/b> Changing site navigation only<\/span><\/li>\n
                                2. <\/b> Creating Appian users from email addresses<\/span><\/li>\n
                                3. <\/b> Executing SQL against an external database and using results in process variables<\/span><\/li>\n
                                4. <\/b> Editing interface components at runtime<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Executing SQL against an external database and using results in process variables<\/b><\/p>\n

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

                                  The Query Database smart service allows a process model to execute SQL against an external database. It can retrieve information and use the results to update or create process-variable values. The smart service can also execute SQL operations such as creating tables and selecting, inserting, or updating rows, although Appian recommends purpose-built data services for common insert, update, and delete operations when appropriate. Since direct SQL introduces more database-specific implementation detail, senior developers should use it deliberately. Appian also recommends placing the Query Database smart service in a subprocess as a best-practice organizational pattern.<\/span><\/p>\n

                                  Question 237. What does Appian recommend as a best practice when using the Query Database smart service?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Place the Query Database smart service in a subprocess<\/span><\/li>\n
                                  2. <\/b> Always place it inside an attended User Input Task<\/span><\/li>\n
                                  3. <\/b> Execute every query twice to verify the output<\/span><\/li>\n
                                  4. <\/b> Never save query results into process variables<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Place the Query Database smart service in a subprocess<\/b><\/p>\n

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

                                    Appian’s documentation recommends placing the Query Database smart service inside a subprocess. Encapsulating database-specific activity can keep the parent workflow cleaner and make the data-access logic easier to isolate, troubleshoot, and potentially reuse. This recommendation is especially relevant in older or specialized process designs that execute direct SQL rather than using record-oriented data access. Developers should still evaluate whether direct database querying is the best architecture, because modern Appian applications often benefit from record types and other supported data services. When Query Database is necessary, isolating the operation improves organization and keeps detailed implementation logic away from the high-level business process.<\/span><\/p>\n

                                    Question 238. A process uses Query Database to retrieve a very large dataset and retains that dataset in process variables for months. What is a key concern?<\/b><\/p>\n

                                      \n
                                    1. <\/b> The process automatically converts to a site<\/span><\/li>\n
                                    2. <\/b> Large process datasets can increase execution-engine memory and storage consumption<\/span><\/li>\n
                                    3. <\/b> Query Database permanently disables archiving<\/span><\/li>\n
                                    4. <\/b> Appian automatically removes all query results after one minute<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Large process datasets can increase execution-engine memory and storage consumption<\/b><\/p>\n

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

                                      Appian warns developers to manage process memory consumption carefully when process instances contain large datasets. Data retained in process variables contributes to process-engine resource consumption, and long-lived instances can increase both memory and storage requirements. Appropriate process archiving or deletion policies can help manage this impact after instances no longer need to remain active. Developers should also avoid loading and retaining more database data than the workflow actually requires. A query that technically succeeds during testing may still create scalability issues in production when many process instances each retain large collections of information for extended periods.<\/span><\/p>\n

                                      Question 239. A Write to Data Store Entity operation fails because a supplied text value is longer than the target database column allows. Which corrective action is appropriate?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Disable all process security<\/span><\/li>\n
                                      2. <\/b> Replace the process model with a site<\/span><\/li>\n
                                      3. <\/b> Delete every CDT field except the failing field<\/span><\/li>\n
                                      4. <\/b> Validate the input length or adjust the compatible database\/CDT column definition<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 4. Validate the input length or adjust the compatible database\/CDT column definition<\/b><\/p>\n

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

                                        Database write failures commonly occur when application data violates the constraints of the target table. If a text value exceeds the target column’s maximum length, developers can prevent invalid submissions through interface validation or change the compatible database and CDT definitions when the business requirement genuinely requires a larger value. Appian troubleshooting guidance also identifies CDT JPA column-length configuration as one way to align application and database expectations. The correct solution should reflect the actual business rule rather than merely bypassing the error. Validating data earlier generally produces a better user experience than allowing a database node to fail after submission.<\/span><\/p>\n

                                        Question 240. A senior developer is reviewing a process that generates reports, sends email notifications, performs direct database queries, and creates output documents. Which design approach BEST supports reliability and maintainability?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Retrieve unlimited data, keep it in process variables indefinitely, and email all results directly<\/span><\/li>\n
                                        2. <\/b> Put every database and document operation into one oversized attended task<\/span><\/li>\n
                                        3. <\/b> Limit retrieved and exported data, isolate specialized database logic, manage generated documents explicitly, validate inputs, and avoid sending sensitive information insecurely<\/span><\/li>\n
                                        4. <\/b> Replace all process variables with email subjects<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Limit retrieved and exported data, isolate specialized database logic, manage generated documents explicitly, validate inputs, and avoid sending sensitive information insecurely<\/b><\/p>\n

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

                                          Reliable Appian process architecture considers data volume, process memory, database behavior, document lifecycle, and communication security together. Queries should retrieve only the information genuinely required, especially when results may remain in process variables. Specialized direct-database logic can be isolated in subprocesses, while generated exports and template-based documents should be stored and passed using explicit Document values. Input validation should prevent avoidable database failures before information reaches persistence nodes. Finally, sensitive business information should not be casually placed into unencrypted email content or attachments. Combining these practices produces workflows that are easier to troubleshoot, scale, secure, and maintain.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Appian ACD201 Exam Dumps and Practice Test Dumps. Question 221. A developer needs to safely retrieve the firstName field from a CDT variable that might be null. Which approach is recommended? Convert the CDT to a document before reading the field Always use direct dot notation regardless of null values Use index() with […]<\/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\/20716"}],"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=20716"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20716\/revisions"}],"predecessor-version":[{"id":20717,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20716\/revisions\/20717"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=20716"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=20716"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=20716"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}