How do you generate PowerPoint with Node.js?

Use a PPTX library when your code already knows every slide element, or call an AI presentation API when you want Node.js to send a brief and receive a designed, editable deck. The API approach reduces the amount of content planning, layout selection, visual sourcing, and export code your team maintains.

Set up the Node.js project

Node.js 20 or newer includes fetch. Create a project and keep the secret in a local environment file:

mkdir node-presentation-api
cd node-presentation-api
npm init -y

# .env — do not commit
PRESENTON_API_KEY=replace_with_your_private_key

Add .env to .gitignore. In production, use your hosting provider’s secret manager.

Generate an editable PPTX

const response = await fetch(
  "https://api.presenton.ai/api/v3/presentation/generate",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.PRESENTON_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      content:
        "Create an eight-slide customer onboarding deck for a B2B analytics product.",
      n_slides: 8,
      instructions: "Use one takeaway per slide and end with next steps.",
      tone: "professional",
      verbosity: "concise",
      standard_template: "general",
      export_as: "pptx"
    }),
    signal: AbortSignal.timeout(180_000)
  }
);

if (!response.ok) {
  throw new Error(`Generation failed with ${response.status}`);
}

const result = await response.json();
console.log(result.presentation_id, result.path, result.edit_path);

Do not print response bodies indiscriminately in production. They may include user-specific paths or upstream diagnostic information.

Put the API behind an Express endpoint

The browser should send a short product-level request to your backend. The backend applies defaults and allowed ranges.

app.post("/api/presentations", async (req, res) => {
  const brief = String(req.body.brief || "").trim();
  const slides = Math.min(Math.max(Number(req.body.slides) || 8, 3), 20);

  if (brief.length < 30 || brief.length > 20_000) {
    return res.status(422).json({ error: "Provide a valid presentation brief." });
  }

  const upstream = await fetch(
    "https://api.presenton.ai/api/v3/presentation/generate/async",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.PRESENTON_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        content: brief,
        n_slides: slides,
        tone: "professional",
        verbosity: "concise",
        standard_template: "general",
        export_as: "pptx"
      }),
      signal: AbortSignal.timeout(20_000)
    }
  );

  if (!upstream.ok) {
    return res.status(502).json({ error: "Presentation job could not start." });
  }

  const task = await upstream.json();
  // Save task.id with the authenticated user before returning it.
  res.status(202).json({ taskId: task.id, status: "queued" });
});

Check asynchronous job status

Expose your own status endpoint. It should look up the local job, verify that it belongs to the current user, and then fetch or return the latest safe status.

const encodedTaskId = encodeURIComponent(job.providerTaskId);
const upstream = await fetch(
  `https://api.presenton.ai/api/v3/async-task/status/${encodedTaskId}`,
  {
    headers: { Authorization: `Bearer ${process.env.PRESENTON_API_KEY}` },
    signal: AbortSignal.timeout(15_000)
  }
);

const task = await upstream.json();

if (task.status === "completed") {
  // Persist approved result fields, then return a safe application response.
}

Use bounded polling with increasing intervals, or subscribe to webhooks for larger systems. A page refresh should not lose the job because the database—not browser memory—is the source of truth.

Handle presentation downloads safely

You can return an authorized provider URL or proxy the file through your application. Proxying provides stronger access control but increases bandwidth and storage responsibility. Whichever method you choose:

• verify the authenticated user’s ownership;
• allow only expected HTTPS hosts;
• set a safe filename and content type;
• avoid logging complete download URLs;
• expire local records and files according to policy.

Make the Node.js workflow reliable

Should you use PptxGenJS instead?

PptxGenJS is a good choice when your Node application needs deterministic control over slide objects and already owns the layout logic. A presentation API is a better fit when users provide briefs or documents and expect the system to create the outline, narrative, layout, and visuals. A hybrid workflow can generate a deck through an API and apply narrowly tested post-processing afterward.