Configure OAuth Server-to-Server Access for AEM Forms Communications Synchronous APIs

1. On the Program Overview page

2. Click “Environments” in the left side menu. You can see a list of all environments

3. Click the specific environment name to view details

   

1. On the Program Overview page

2. Locate the Environments section

3. Click “Show All” to view all environments

4. Click the ellipsis menu (…) next to the environment

5. Select “View Details”

   

1. From the Quick Start section, click Create new project

2. A new project is created with a default name

   

3. Click Edit project in the top right corner

   

4. Provide a meaningful name (e.g., “formsproject”)

5. Click Save

   

1. Click All Projects from the Adobe Developer Console

   

2. Locate your project and click to open it.

   

Generate access tokens manually in Adobe Developer Console:

1. Click the “Generate access token” button in your project’s API section

2. Copy the generated access token

   

Generate tokens programmatically using Adobe IMS API:

Required Credentials:

• Client ID
• Client Secret
• Scopes (typically: openid, AdobeID, read_organizations, additional_info.projectedProductContext, read_pc.dma_aem_cloud, aem.document)

Token Endpoint:

    https://ims-na1.adobelogin.com/ims/token/v3

Sample Request (curl):

    curl -X POST 'https://ims-na1.adobelogin.com/ims/token/v3' \
    -H 'Content-Type: application/x-www-form-urlencoded' \
    -d 'grant_type=client_credentials' \
    -d 'client_id=<YOUR_CLIENT_ID>' \
    -d 'client_secret=<YOUR_CLIENT_SECRET>' \
    -d 'scope=AdobeID,openid,read_organizations'

Response:

        {
        "access_token": "eyJhbGciOiJSUz...",
        "token_type": "bearer",
        "expires_in": 86399
        }

Swagger UI provides an interactive interface for testing APIs without writing code.Use the Try it feature to invoke and test the generate PDF Forms Communication API.

1. Navigate to Forms Communication API Reference and open the Forms Communication API documentation in your browser.

2. Expand the Document Generation section and select Generates a fillable PDF form from an XDP or PDF template, optionally with data merging.

3. In the right pane, click Try it.

   

4. Enter the following values:

   table 0-row-3 1-row-3 2-row-3 3-row-3 4-row-3 5-row-3
   Section	Parameter	Value
   bucket	AEM instance	AEM instance name without the Adobe domain name (.adobeaemcloud.com) For example, use pXXXXX-eYYYYY as bucket.
   Security	Bearer Token	Use the access token from the Adobe Developer Console Project’s OAuth Server-to-Server credential
   Body	template	Upload an XDP to generate the PDF form. For example, you can use this XDP to generate a PDF.
   Body	data	An optional XML file containing the data to be merged with the template to generate a pre-filled PDF form. For example, you can use this XML to generate a PDF.
   Parameters	X-Adobe-Accept-Experimental	1

5. Click Send to invoke the API

   

6. Check the response in the Response tab:

   • If the response code is 200, it means the PDF is created successfully.
   • If the response code is 400, it means the request parameters are invalid or malformed.
   • If the response code is 500, it means there is an internal server error.
   • If the response code is 403, it means there is an authorization error.

   In this case, the response code is 200, it means that the PDF is generated successfully:

   

   Now, you can download the created PDF using the Download button and view it in PDF viewer:

   

   note note
   NOTE
   For testing purposes, you can also use the Postman, curl, or any other REST client to invoke the AEM APIs.

Develop a Node.js application to generate a fillable PDF form from an XDP template and an XML data file using the Document Services API

Prerequisites

• Node.js installed on your system
• Active AEM as a Cloud Service instance
• Bearer token for API authentication from Adobe Developer Console
• Sample XDP File: ClosingForm.xdp
• Sample XML File: ClosingForm.xml

To develop the Node.js application, follow the step-by-step-development:

Step 1: Create a New Node.js Project

Open the cmd/terminal and execute the below commands:

# Create a new directory
mkdir demo-nodejs-generate-pdf
cd demo-nodejs-generate-pdf

##### Initialize Node.js project
npm init -y

Step 2: Install Required Dependencies

Install the node-fetch, dotenv, and form-data libraries to make HTTP requests, read environment variables, and handle form data respectively.

npm install node-fetch
npm install dotenv
npm install form-data

Step 3: Update package.json

1. Open the cmd/terminal and run the command:

   code language-bash
   code .

   

   It opens the project in the code editor.

2. Update the package.json file to add the type to module.

   code language-bash
   { "name": "demo-nodejs-generate-pdf", "version": "1.0.0", "type": "module", "main": "index.js", }

   

Step 4: Create a .env File

1. Create .env file at the root level of an project

2. Add the following configuration and replace the placeholders with the actual values from the ADC Project’s OAuth Server-to-Server credential.

   code language-bash
   CLIENT_ID=<ADC Project OAuth Server-to-Server credential ClientID> CLIENT_SECRET=<ADC Project OAuth Server-to-Server credential Client Secret> SCOPES=<ADC Project OAuth Server-to-Server credential Scopes>

   

   note note
   NOTE
   You can copy the CLIENT_ID, CLIENT_SECRET and SCOPES from the Adobe Developer Console project.

Step 5: Create src/index.js

1. Create index.js file at the Project’s root level
2. Add the following code, and replace the placeholders with the actual values:

// Import the dotenv configuration to load environment variables from the .env file
import "dotenv/config";

// Import fetch for making HTTP requests
import fetch from "node-fetch";
import fs from "fs";
import FormData from "form-data";

// REPLACE THE FOLLOWING VALUE WITH YOUR OWN
const bucket = <bucket-value>; // Your AEM Cloud Service Bucket name
const xdpFilePath = <xdp-file>;
const xmlFilePath = <xml-file>;

// Load environment variables
const clientId = process.env.CLIENT_ID;
const clientSecret = process.env.CLIENT_SECRET;
const scopes = process.env.SCOPES;

// Adobe IMS endpoint for obtaining an access token
const adobeIMSV3TokenEndpointURL = "https://ims-na1.adobelogin.com/ims/token/v3";

// Function to get an access token
const getAccessToken = async () => {
    console.log("Getting access token from IMS...");

    const options = {
        method: "POST",
        headers: {
            "Content-Type": "application/x-www-form-urlencoded",
        },
        body: `grant_type=client_credentials&client_id=${clientId}&client_secret=${clientSecret}&scope=${scopes}`,
    };

    const response = await fetch(adobeIMSV3TokenEndpointURL, options);
    const responseJSON = await response.json();

    console.log("Access token received.");
    return responseJSON.access_token;
};

// Function to generate PDF form from XDP and XML
const generatePDF = async () => {
    const accessToken = await getAccessToken();

    console.log("Generating PDF form from XDP and XML...");

    // Read XDP and XML files
    const xdpFile = fs.readFileSync(xdpFilePath);
    const xmlFile = fs.readFileSync(xmlFilePath);

    const url = `https://${bucket}.adobeaemcloud.com/adobe/document/generate/pdfform`;

    const formData = new FormData();
    formData.append("template", xdpFile, {
        filename: "form.xdp",
        contentType: "application/vnd.adobe.xdp+xml"
    });
    formData.append("data", xmlFile, {
        filename: "data.xml",
        contentType: "application/xml"
    });

    const response = await fetch(url, {
        method: "POST",
        headers: {
            Authorization: `Bearer ${accessToken}`,
            "X-Api-Key": clientId,
            "X-Adobe-Accept-Experimental": "1",
            ...formData.getHeaders()
        },
        body: formData,
    });

    if (response.ok) {
        const arrayBuffer = await response.arrayBuffer();
        fs.writeFileSync("generatedForm.pdf", Buffer.from(arrayBuffer));
        console.log("✅ PDF form generated successfully (saved as generatedForm.pdf)");
    } else {
        console.error("❌ Failed to generate PDF. Status:", response.status);
        console.error(await response.text());
    }
};

// Run the PDF generation function
generatePDF();

Step 6: Run the Application

node src/index.js

The PDF is created in the demo-nodejs-generate-pdf folder. Navigate to the folder to find the generated file named generatedForm.pdf.