# Design File Converter: Figma, PSD, DWG, IDML, RAW to PDF, PNG (`shatrix/design-file-converter`) Actor

Convert files that are hard to open without paid desktop software: InDesign IDML/INDD, AutoCAD DWG/DXF, Lottie animations, Photoshop PSD/PSB, GIMP XCF, Krita, Figma .fig, Illustrator AI, EPS, SVG and camera RAW photos into PDF, PNG, JPG, WebP, SVG, MP4, GIF or WebM.

- **URL**: https://apify.com/shatrix/design-file-converter.md
- **Developed by:** [Sherif Elsayed](https://apify.com/shatrix) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 file converteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Design File Converter: Figma, PSD, DWG, IDML, RAW to PDF, PNG

Convert design files that normally need expensive desktop software, in bulk, without installing
anything:

| Input | Becomes |
|---|---|
| InDesign IDML (and INDD, best effort) | PDF, or PNG/JPG/WebP per page |
| AutoCAD DWG, DXF | PDF (vector), SVG, PNG, JPG, WebP |
| Lottie animations (.json, .lottie) | MP4, GIF, WebM, or a PNG frame |
| Photoshop PSD/PSB, GIMP XCF, Krita KRA, OpenRaster, Paint.NET PDN, TIFF, EXR | PNG, JPG, WebP (flattened) |
| Figma .fig (best effort) | PNG, JPG, WebP, SVG or PDF per frame |
| Illustrator AI, EPS, SVG, EMF, WMF, Affinity | PDF, SVG, PNG, JPG, WebP |
| Camera RAW: DNG, CR2, CR3, ARW, NEF, RAF, RW2, RWL, ORF, PEF, SRW | JPG, PNG, WebP |

Every format in the table was tested with real-world files except OpenRaster (tested with files
made by open-source tools): photos from 11 camera and phone RAW formats, Autodesk sample drawings
and DWG versions R2000 to R2018, layered files from Photoshop, GIMP, Krita, Paint.NET and
Affinity, Illustrator, EPS, EMF/WMF and SVG art, InDesign IDML with matching INDD files, Figma
.fig files, and Lottie and dotLottie animations.

Typical uses: previews and thumbnails for a digital asset manager or CMS, client-ready PDFs of
CAD drawings, MP4/GIF versions of Lottie animations for places that can't play Lottie,
batch-developing RAW photos, opening a colleague's InDesign or Photoshop file without a licence.

### Input

```json
{
  "files": [
    "https://example.com/brochure.idml",
    "https://example.com/floorplan.dwg",
    "https://example.com/loader.json"
  ],
  "outputFormat": "auto"
}
```

- `files`: up to 100 URLs per run; or upload one file in `file`. Leave both empty to try a
  built-in sample drawing for free.
- `outputFormat`: `auto` picks PDF for InDesign and CAD, MP4 for Lottie, JPG for RAW and PNG for
  everything else; or choose `pdf`, `png`, `jpg`, `webp`, `svg`, `mp4`, `gif`, `webm`.
- Options: `scale` (pixels per point, default 2), `allPages` (InDesign pages as images),
  `quality` (JPG/WebP), `maxSize` (RAW long edge), `frameTime` (Lottie still frame),
  `transparent` (Lottie WebM/GIF/PNG with a transparent background), `cadBlackAndWhite` (CAD
  plotted black on white).

The type is taken from the file extension, or detected from the file's contents.

### Output

One dataset row per input file:

```json
{
  "source": "https://example.com/floorplan.dwg",
  "fileName": "floorplan.dwg",
  "inputType": "cad",
  "outputFormat": "pdf",
  "status": "converted",
  "url": "https://api.apify.com/v2/key-value-stores/.../records/002-floorplan.pdf",
  "outputs": [{"fileName": "floorplan.pdf", "url": "...", "contentType": "application/pdf", "bytes": 3136}],
  "warnings": [],
  "error": null
}
```

Multi-page and multi-frame inputs list every file in `outputs`. A file that can't be converted
gets `"status": "failed"` with the reason in `error`, and is not charged. The free sample run's
row has `"status": "sample"`.

### Use with AI agents (MCP)

`https://mcp.apify.com?tools=shatrix/design-file-converter`

### Use from code

```bash
curl -X POST "https://api.apify.com/v2/acts/shatrix~design-file-converter/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"files": ["https://example.com/floorplan.dwg"], "outputFormat": "pdf"}'
```

### Pricing

Pay per event: one charge per converted file, and a higher one per rendered Lottie video (see
the Pricing tab). Failed files are not charged. Set a maximum cost per run to cap spending; the
run stops before the file that would exceed it.

### Limits and notes

- Up to 100 files and 512 MB per file per run.
- Layered images are flattened (layers, masks and blend modes are combined into one image).
  Multi-page TIFFs give their first page. CMYK Photoshop files with spot channels can lose their
  colours.
- If a conversion comes out blank (nothing visible), the file fails with a message and is not
  charged. Some EMF drawings (clip paths with embedded pictures) do this.
- Illustrator files from before version 9 (PostScript-based .ai) can render wrongly: a real
  Illustrator 7 logo lost its gradients. Modern (PDF-based) .ai files rendered correctly.
- CAD drawings are drawn in model space with their own colours; turn on `cadBlackAndWhite` to
  plot everything black on white (monochrome plot style) on an A3 page in the drawing's
  orientation.
- Lottie MP4 has a black background (MP4 has no transparency); with `transparent` on, WebM
  (VP9 with alpha), GIF and PNG keep the background transparent.
- Fonts missing from a file fall back to installed open fonts (including Noto for most scripts);
  the row's `warnings` say so.
- Figma .fig, InDesign INDD and Affinity files are supported on a best-effort basis: only a few
  real samples were available to test (and no Affinity Photo file). Check results for important
  work.

### Credits

Built on open-source engines from the ArtCraft project (DesignCraft, CADCraft, EffectCraft,
PhotoCraft, FigCraft, VectorCraft, LightCraft; MIT OR Apache-2.0). Their license texts ship in
the Actor's image under `/opt/engines/licenses/`. This Actor is not affiliated with or endorsed
by the ArtCraft project, Adobe, Autodesk, Figma or Airbnb (Lottie).

# Actor input Schema

## `files` (type: `array`):

Links to the files to convert (up to 100). Leave this and the upload empty to try a built-in sample drawing for free. Supported: InDesign .idml/.indd, CAD .dwg/.dxf, Lottie .json/.lottie, images .psd/.psb/.xcf/.kra/.ora/.pdn/.tif/.exr, Figma .fig, vector .ai/.eps/.svg/.emf/.wmf/.afdesign, camera RAW .dng/.cr2/.cr3/.arw/.nef/.raf/.rw2/.orf/.pef/.srw.

## `file` (type: `string`):

Or upload one file (or give its URL) here.

## `outputFormat` (type: `string`):

auto picks: PDF for InDesign and CAD, MP4 for Lottie, JPG for RAW, PNG for everything else. Possible per input: InDesign pdf/png/jpg/webp; CAD pdf/svg/png/jpg/webp; Lottie mp4/gif/webm/png (one frame); layered images png/jpg/webp; Figma png/jpg/webp/svg/pdf (one file per frame); vector pdf/svg/png/jpg/webp; RAW jpg/png/webp.

## `scale` (type: `number`):

Pixels per point for images made from InDesign pages, vector art and Figma frames (2 = sharp, retina-ready).

## `allPages` (type: `boolean`):

For InDesign files converted to images: one image per page. Off: the first page only.

## `quality` (type: `integer`):

1-100. Empty uses each engine's default.

## `maxSize` (type: `integer`):

For camera RAW photos: the long edge of the output in pixels. Empty keeps the full size.

## `frameTime` (type: `number`):

For Lottie to PNG: which moment to draw, in seconds. Empty draws the middle of the animation.

## `transparent` (type: `boolean`):

For Lottie to WebM, GIF or PNG: keep the background transparent. MP4 can't be transparent.

## `cadBlackAndWhite` (type: `boolean`):

For DWG/DXF: plot every line and text in black on white (monochrome plot style) on an A3 page in the drawing's orientation, instead of the drawing's screen colours.

## Actor input object example

```json
{
  "files": [],
  "outputFormat": "auto",
  "scale": 2,
  "allPages": true,
  "transparent": false,
  "cadBlackAndWhite": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `files` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "files": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("shatrix/design-file-converter").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "files": [] }

# Run the Actor and wait for it to finish
run = client.actor("shatrix/design-file-converter").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "files": []
}' |
apify call shatrix/design-file-converter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shatrix/design-file-converter"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/onWmQrFA18GB3AfSq/builds/qOaBaUZJV4cAUNZjl/openapi.json