From adobe-for-creativity
Orchestrates InDesign data merge from CSV/TSV and .indd/PDF template. Creates placeholders, converts PDF to INDD, and exports merged PDFs.
How this skill is triggered — by the user, by Claude, or both
Slash command
/adobe-for-creativity:adobe-create-pdfs-from-dataThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
Orchestrates the complete InDesign data merge pipeline. The naive path — calling
Orchestrates the complete InDesign data merge pipeline. The naive path — calling
document_merge_data_layout directly — often fails because the template must have its
data-merge fields linked to the correct data columns before merging. This skill ensures
that linkage is in place first, including automatic placeholder creation when the template
has none, and PDF-to-INDD conversion when the user only has a PDF layout.
Pipeline at a glance:
| Phase | What happens | Gate |
|---|---|---|
| 0 | Adobe init | — |
| 1a | Convert PDF template → .indd (skip if already .indd) | ⛔ GATE 1 |
| 1b | Confirm .indd URL and data file are available | — |
| 2 | Export IDML; detect existing merge placeholders | — |
| 3 | Create placeholders via LLM mapping (only if Phase 2 found none) | ⛔ GATE 2 |
| 4 | Run document_merge_data_layout | — |
| Step | Tool | Notes |
|---|---|---|
| Initialize Adobe tools | adobe_mandatory_init | Always call first |
| Inspect PDF pages | asset_inline_preview | Returns rendered preview per page |
| Preview PDF pages (fallback) | asset_preview_file | Use if asset_inline_preview unavailable |
| Upload condensed template PDF | asset_initialize_file_upload + asset_finalize_file_upload | Required before convert_pdf_to_indd |
| Convert PDF → INDD | convert_pdf_to_indd | Use extractedDocumentPresignedUrls as inddUrl |
| Export IDML | export_idml | Outputs presigned IDML URL for inspection |
| Generate mapping prompt | generate_indd_mapping_prompt | Read-only; returns prompt — you run it through an LLM |
| Create placeholders in INDD | prepare_indd_merge_template | Only after user approves mapping |
| Run data merge | document_merge_data_layout | Template + data → merged PDF |
Two rules are non-negotiable and override all efficiency instincts.
Never call convert_pdf_to_indd on a user-supplied PDF without first inspecting its
page layout structure. A multi-page PDF (e.g. a prior merged output) produces a multi-page INDD
which breaks the merge. Always distil it to a single-layout condensed PDF first.
Never call prepare_indd_merge_template in the same turn you generate or display the mapping JSON.
Show the mapping summary + raw JSON, ask for approval, and end the turn. Only call
prepare_indd_merge_template after the user explicitly approves in a later turn.
{ "skill_name": "adobe-create-pdfs-from-data", "skill_version": "1.0.1" }
Call adobe_mandatory_init once, before any other Adobe tool.
.indd)When to run: The user's template is a PDF (or any non-INDD layout). If you already have a
usable .indd URL, skip directly to Step 1b.
Record the user-supplied PDF URL as originalPdfUrl.
Call asset_inline_preview on the PDF (or asset_preview_file as fallback). Record totalPages.
If totalPages == 1: set templatePdfUrl = originalPdfUrl and skip to Sub-step 5.
Look at each preview image. Ask: "If I removed all text and image content and compared only the skeleton — frame positions, structural regions — would this page match another page?"
Group pages by layout skeleton into layoutGroups:
layoutGroups = {
"layout-A": [1, 2, 3, ...], // pages sharing layout A
"layout-B": [N+1, ...], // pages with a distinct layout B
}
Pick templatePages as a single representative page:
layoutGroups has exactly 1 entry: templatePages = [first page in that group].layoutGroups has >1 entry: ask the user which layout group to use (or default to the group with the most pages) and set templatePages to one page from that group.Tell the user:
"Your PDF has {totalPages} pages. I found {N} unique layout(s). I'll use page {templatePages[0]} as the template. (If you need multiple layouts, we can run separate merges per layout.)"
Download the PDF from {originalPdfUrl} and extract only page(s) {templatePages} (1-indexed) to template-condensed.pdf using PyMuPDF (fitz). Report the absolute file path as intermediatePdfLocalPath.
Record the path as intermediatePdfLocalPath.
asset_initialize_file_upload({ path: "template-condensed.pdf", media_type: "application/pdf" })
// PUT the local file bytes to the returned upload URL, then:
asset_finalize_file_upload({ filename: "template-condensed.pdf", transfer_document: <from initialize response> })
Record the resulting presigned URL as templatePdfUrl.
convert_pdf_to_indd:
pdfSourceUrl: {templatePdfUrl}
outputFormat: "indd"
embedLinks: false
waitForCompletion: true
includeAdobeZipDownloadLinksInResult: false
Use the first entry in extractedDocumentPresignedUrls as inddUrl. If that field is
missing, re-run with embedLinks: true. Do not attempt to download or unzip the output ZIP.
Confirm all inputs are accessible (attached files, URLs from conversation, or prior tool calls):
.indd URL — if missing, prompt the user to upload their templateIf any file is a local attachment without a URL, upload it first:
asset_initialize_file_upload → asset_finalize_file_upload
Record inddUrl and dataUrl. Proceed only when both are confirmed.
Parse the header row of dataUrl. If any column values look like image filenames or paths
(common with @-prefixed image fields in InDesign templates), collect those images:
asset_initialize_file_upload +
asset_finalize_file_upload.additionalImageFiles: a map of { "filename.jpg": "<presignedUrl>", ... } covering
every unique image referenced across all rows.Record additionalImageFiles (or {} if no image columns are present).
export_idml:
assets:
- sourceUrl: {inddUrl} destination: "template.indd"
Record the presigned idmlUrl from the response.
If export_idml fails (missing execute URL), tell the user you cannot proceed with
automatic placeholder creation and ask whether they want to continue manually.
Fetch and unzip the IDML. Build docAnalysis capturing every candidate merge target:
uid, bounds, current text content, any existing <<fieldName>> or <AppliedDataMergeField> tokensuid, bounds, aspect ratio, any @-prefixed image field namesExtract idmlPlaceholders: string[] — unique field names stripped of <</>> wrappers.
If placeholders are found: skip Phase 3 and go directly to Step 4 using inddUrl.
If no placeholders are found: proceed to Step 3.
Parse the header row of dataUrl. Treat the file as delimited text; infer the delimiter if
ambiguous. Preserve exact column name strings as dataColumns: string[].
Call generate_indd_mapping_prompt — this returns a prompt string only; it does not call an LLM:
generate_indd_mapping_prompt:
userRequest: {user's original request}
tier: "standard" (use "complex" for dense templates; "modification" for edits)
idmlPresignedUrl: {idmlUrl}
csvInfo:
headers: {dataColumns}
data_types: {inferred types}
sample_data: {first 2–3 rows}
Run the returned prompt through an LLM requiring JSON-only output. Record as mappingJson.
Call generate_indd_mapping_prompt again with the same inputs, adding:
mappingJson: {mappingJson}
If the response includes filteredMappings (hallucinated UIDs removed), use it as the working
mapping. Fix any errors and re-validate until isValid: true.
After the first successful validation, record:
originalMappingJson — the first validated mapping (use filteredMappings if returned)originalIdmlUrl — the idmlUrl from Step 2 (never overwrite with a post-edit version)originalInddUrl — the inddUrl from Step 1b (never overwrite with mappedInddUrl)Your response for this step must contain exactly:
"Please confirm this mapping (or tell me what to change). I'll apply it to create placeholders in your
.inddand then run the merge."
After that line — no more tool calls, no further narration. End the turn.
If the user requests changes, enter a modification loop:
originalMappingJson — never use an
intermediate draft or mappedInddUrl as the basetier: "modification", passing originalIdmlUrl and
originalMappingJson in modificationContextprepare_indd_merge_template until the user approvesOnly callable after user explicitly approves in a later turn.
prepare_indd_merge_template:
assets:
- sourceUrl: {originalInddUrl} destination: "template.indd"
params: {filteredMappings or validated mappingJson}
Record the first presigned URL from the response as mappedInddUrl.
document_merge_data_layout:
templateSourceUrl: {mappedInddUrl or inddUrl}
templateFileName: "template.indd"
dataSourceUrl: {dataUrl}
additionalImageFiles: {additionalImageFiles} # omit or pass {} if no image columns
outputSpecs: [{ outputMediaType: "application/pdf" }]
recordRange: "All"
Return download links to the user:
"Data merge complete — {N} record(s) rendered. Here are your download links:"
User requests data merge
│
Phase 0: adobe_mandatory_init
│
Already have .indd URL?
YES → Step 1b
NO → Template is PDF?
YES → Step 1a.1: inspect all pages
→ single page? → convert_pdf_to_indd (original URL)
→ multi-page? → identify unique layouts → extract condensed PDF
→ upload → convert_pdf_to_indd → inddUrl
NO → Step 1b (ask for .indd upload)
│
Step 1b: confirm inddUrl + dataUrl
│
Step 2: export_idml → parse IDML for placeholders
│
Placeholders found?
YES → Step 4: document_merge_data_layout
NO → Step 3a: parse data headers
Step 3b: generate_indd_mapping_prompt → LLM → mappingJson
Step 3b.1: validate → filteredMappings
⛔ STOP — show mapping + ask approval — END TURN
│
[Next turn] user approves?
YES → Step 3c: prepare_indd_merge_template → mappedInddUrl
NO → modify against originals → re-validate → ⛔ STOP again
│
Step 4: document_merge_data_layout → return download links
| Situation | Action |
|---|---|
export_idml fails / missing execute URL | Inform user that automatic placeholder creation is unavailable; ask if they want to continue manually |
prepare_indd_merge_template fails / missing execute URL | Ask deployer to set ADOBE_CAPABILITY_SMART_MAPPING_EXECUTE_URL; stop |
| Data file delimiter unclear | Ask the user what delimiter is used and whether the first row is a header |
| Mapping JSON invalid after validation | Re-run LLM with the validation errors; require JSON-only output; retry until isValid: true |
document_merge_data_layout fails | Surface the raw error; suggest checking that template variable names match CSV column headers exactly |
convert_pdf_to_indd fails | Confirm the PDF URL is accessible; retry with embedLinks: true; if still failing, ask user for a native .indd |
No .indd and PDF conversion unavailable | Ask user to export their template as .indd directly |
The IDML export and smart-mapping tools require these environment variables (configure them in your deployment environment):
| Variable | Used by |
|---|---|
ADOBE_CAPABILITY_IDMLEXPORT_EXECUTE_URL | export_idml |
ADOBE_CAPABILITY_SMART_MAPPING_EXECUTE_URL | prepare_indd_merge_template |
ADOBE_CLIENT_ID, ADOBE_CLIENT_SECRET, ADOBE_API_KEY, ADOBE_IMS_ORG_ID, ADOBE_CLIENT_CODE, ADOBE_IMS_TOKEN_URL, ADOBE_API_BASE_URL | All Adobe tools |
npx claudepluginhub anthropics/claude-plugins-official --plugin adobe-for-creativityAutomates Canva design operations via Rube MCP and Composio: list designs, create from scratch or templates, upload assets, manage folders, brand templates, and autofill.
Populates investment banking pitch deck templates with data from Excel/CSV source files. Validates formatting and financial calculations.
Generates print-ready PDFs from scratch, fills form fields, or reformats documents using token-based design systems for reports, proposals, resumes.