# Convert3D

> Documentation for converting, viewing, rendering, compressing, and automating 3D files

This document contains the full content of all documentation pages for AI consumption.

---

## AI 3D generation

**URL:** https://docs.convert3d.org/docs/ai-3d
**Description:** Generate 3D models from images or text

Convert3D can generate GLB models from images or text prompts.

## Image to 3D

Image to 3D takes a 2D image and returns a GLB model.

Go to [convert3d.org/image-to-3d](https://convert3d.org/image-to-3d), upload an image, choose settings, and generate the model.

Common settings include:

- Seed.
- Guidance strength.
- Sampling steps.
- Decimation target.
- Texture size: `1024`, `2048`, or `4096`.

## Text to 3D

Text to 3D first generates an image from your prompt, then converts that image to a GLB model.

Use short, concrete prompts. Include the object, style, and important shape details.

## Output

AI 3D generation returns a `.glb` file. You can then:

- View it in the Convert3D viewer.
- Render it to a PNG.
- Convert it to another supported output format.
- Compress it for web use.

## Limits

AI generation requires sign-in and may be limited by credits, daily usage, or plan limits.

---

## API authentication

**URL:** https://docs.convert3d.org/docs/api-authentication
**Description:** Authenticate API requests with a bearer token

The Convert3D cloud API uses bearer token authentication.

## Header

Send your token in the `Authorization` header:

```txt
Authorization: Bearer YOUR_API_TOKEN
```

## Examples

### curl

```bash
curl https://api.convert3d.org/health \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

### JavaScript

```js
const response = await fetch("https://api.convert3d.org/health", {
  headers: {
    Authorization: `Bearer ${process.env.CONVERT3D_API_TOKEN}`,
  },
});
```

### Python

```py

response = requests.get(
    "https://api.convert3d.org/health",
    headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
    timeout=30,
)
```

## Token errors

If the header is missing:

```json
{
  "error": "Missing Authorization header"
}
```

If the token is invalid:

```json
{
  "error": "Invalid API token"
}
```

Both responses use HTTP `401`.

## Credits and quota

API conversions may consume API conversion credits. If a paid account has no remaining quota, the API returns HTTP `429`.

```json
{
  "error": "API conversion quota exhausted. Upgrade your plan at https://convert3d.org/convert3dapi"
}
```

If a conversion fails after a credit is consumed, Convert3D attempts to refund that credit.

---

## POST /convert

**URL:** https://docs.convert3d.org/docs/api-convert
**Description:** Synchronous file conversion

Use `POST /convert` when you want one request that returns the converted file bytes.

```txt
POST /convert
```

This is the simplest conversion endpoint. For production jobs, larger files, or cleaner retry behavior, use [POST /convert/jobs](/docs/api-create-job).

## Request

Send `multipart/form-data`.

## Examples

### curl

```bash
curl https://api.convert3d.org/convert \
  -F file=@model.glb \
  -F from=glb \
  -F to=usdz \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -o model.usdz
```

### JavaScript

```js

const token = process.env.CONVERT3D_API_TOKEN;
const file = await openAsBlob("model.glb");

const form = new FormData();
form.append("file", file, "model.glb");
form.append("from", "glb");
form.append("to", "usdz");

const response = await fetch("https://api.convert3d.org/convert", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
  },
  body: form,
});

if (!response.ok) {
  throw new Error(await response.text());
}

const bytes = new Uint8Array(await response.arrayBuffer());
await writeFile("model.usdz", bytes);
```

### Python

```py

with open("model.glb", "rb") as file:
    response = requests.post(
        "https://api.convert3d.org/convert",
        headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
        files={"file": ("model.glb", file)},
        data={"from": "glb", "to": "usdz"},
        timeout=300,
    )

response.raise_for_status()

with open("model.usdz", "wb") as output:
    output.write(response.content)
```

## Response

On success, the response body is the converted file.

Important response headers:

```txt
Content-Type: application/octet-stream
Content-Disposition: attachment; filename="model.usdz"
```

## Errors

Errors are JSON.

```json
{
  "error": "Missing 'file' field"
}
```

See [API errors](/docs/api-errors) for status codes and retry guidance.

---

## POST /convert/jobs

**URL:** https://docs.convert3d.org/docs/api-create-job
**Description:** Async conversion job creation

Use `POST /convert/jobs` to start an async conversion job.

```txt
POST /convert/jobs
```

This is the recommended endpoint for production integrations. You get a job ID, poll status, then download the result.

## Request: multipart upload

Send `multipart/form-data` when you want to upload the file and create the job in one request.

## Examples

### curl

```bash
curl https://api.convert3d.org/convert/jobs \
  -F file=@model.obj \
  -F from=obj \
  -F to=glb \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

### JavaScript

```js

const token = process.env.CONVERT3D_API_TOKEN;
const file = await openAsBlob("model.obj");

const form = new FormData();
form.append("file", file, "model.obj");
form.append("from", "obj");
form.append("to", "glb");

const response = await fetch("https://api.convert3d.org/convert/jobs", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
  },
  body: form,
});

if (!response.ok) {
  throw new Error(await response.text());
}

const job = await response.json();
console.log(job.id);
```

### Python

```py

with open("model.obj", "rb") as file:
    response = requests.post(
        "https://api.convert3d.org/convert/jobs",
        headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
        files={"file": ("model.obj", file)},
        data={"from": "obj", "to": "glb"},
        timeout=300,
    )

response.raise_for_status()
job = response.json()
print(job["id"])
```

## Request: upload-first JSON

Use JSON after creating an upload URL and uploading the source file.

```json
{
  "bucket": "uploads",
  "key": "uploads/abc123/large-model.glb",
  "fileName": "large-model.glb",
  "from": "glb",
  "to": "usdz"
}
```

See [GET /upload-url](/docs/api-upload-url) for the full upload-first flow.

## Response

```json
{
  "id": "job_123",
  "status": "queued",
  "progress": 0
}
```

## Next step

Poll [GET /convert/jobs/:id](/docs/api-get-job) every 2-5 seconds until the job is `success` or `failed`.

---

## GET /convert/jobs/:id/download

**URL:** https://docs.convert3d.org/docs/api-download-job
**Description:** Async job download

Use `GET /convert/jobs/:id/download` after a job finishes.

```txt
GET /convert/jobs/:id/download
```

## Path parameters

## Examples

### curl

```bash
curl https://api.convert3d.org/convert/jobs/job_123/download \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -o model.glb
```

### JavaScript

```js

const token = process.env.CONVERT3D_API_TOKEN;
const jobId = "job_123";

const response = await fetch(
  `https://api.convert3d.org/convert/jobs/${jobId}/download`,
  {
    headers: {
      Authorization: `Bearer ${token}`,
    },
  }
);

if (response.status === 409) {
  throw new Error("Job is not ready yet");
}

if (!response.ok) {
  throw new Error(await response.text());
}

const contentType = response.headers.get("content-type") || "";

if (contentType.includes("application/json")) {
  const { url } = await response.json();
  console.log(url);
} else {
  const bytes = new Uint8Array(await response.arrayBuffer());
  await writeFile("model.glb", bytes);
}
```

### Python

```py

job_id = "job_123"

response = requests.get(
    f"https://api.convert3d.org/convert/jobs/{job_id}/download",
    headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
    timeout=300,
)

if response.status_code == 409:
    raise RuntimeError("Job is not ready yet")

response.raise_for_status()

if response.headers.get("content-type", "").startswith("application/json"):
    print(response.json()["url"])
else:
    with open("model.glb", "wb") as output:
        output.write(response.content)
```

## Response

Depending on storage mode, the response is either:

- A JSON object with a signed download URL.
- The converted file bytes.

Signed URL response:

```json
{
  "url": "https://storage.convert3d.org/converted/model.glb?signature=..."
}
```

If the file is not ready:

```json
{
  "error": "Not ready"
}
```

HTTP status: `409`.

## Before downloading

Poll [GET /convert/jobs/:id](/docs/api-get-job) until the job status is `success`.

---

## API errors

**URL:** https://docs.convert3d.org/docs/api-errors
**Description:** HTTP status codes and error handling

API errors are returned as JSON.

```json
{
  "error": "Message"
}
```

## Status codes

| Status | Meaning | Common cause |
| --- | --- | --- |
| `400` | Bad request | Missing file, invalid JSON, wrong content type. |
| `401` | Unauthorized | Missing or invalid API token. |
| `403` | Forbidden | Invalid upload bucket. |
| `404` | Not found | Unknown job ID or unsupported local-mode endpoint. |
| `409` | Conflict | Job download requested before the file is ready. |
| `429` | Too many requests or quota exhausted | API conversion quota is exhausted. |
| `500` | Server error | Conversion failed or an unexpected error occurred. |

## Common errors

### Missing file

```json
{
  "error": "Missing 'file' field"
}
```

Send `multipart/form-data` with a `file` field.

### Invalid token

```json
{
  "error": "Invalid API token"
}
```

Check that the header is exactly:

```txt
Authorization: Bearer YOUR_API_TOKEN
```

### Unsupported format

```json
{
  "error": "Unsupported file format"
}
```

Check [supported formats](/docs/formats). If the file extension is wrong, pass `from`.

### Not ready

```json
{
  "error": "Not ready"
}
```

The job has not completed. Poll `/convert/jobs/:id` until `status` is `success`.

## Retry guidance

- Retry network failures and `5xx` responses with backoff.
- Do not retry `400`, `401`, or `403` until the request is fixed.
- For async jobs, retry job creation only if you did not receive a job ID.
- If a job returns `failed`, create a new job after fixing the input.

---

## API examples

**URL:** https://docs.convert3d.org/docs/api-examples
**Description:** JavaScript, Python, React, and model-viewer examples

These examples use the async job flow:

1. Create a job with [POST /convert/jobs](/docs/api-create-job).
2. Poll [GET /convert/jobs/:id](/docs/api-get-job).
3. Use the returned signed URL, or call [GET /convert/jobs/:id/download](/docs/api-download-job).

## JavaScript

Use this in a browser or frontend app where you already have a `File`.

```js
async function convertModel(file, apiToken, to = "glb") {
  const form = new FormData();
  form.append("file", file);
  form.append("from", file.name.split(".").pop().toLowerCase());
  form.append("to", to);

  const createResponse = await fetch("https://api.convert3d.org/convert/jobs", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiToken}`,
    },
    body: form,
  });

  if (!createResponse.ok) {
    throw new Error(await createResponse.text());
  }

  const job = await createResponse.json();

  while (true) {
    const statusResponse = await fetch(
      `https://api.convert3d.org/convert/jobs/${job.id}`,
      {
        headers: {
          Authorization: `Bearer ${apiToken}`,
        },
      }
    );

    if (!statusResponse.ok) {
      throw new Error(await statusResponse.text());
    }

    const status = await statusResponse.json();

    if (status.status === "success") {
      return status.signedUrl;
    }

    if (status.status === "failed") {
      throw new Error(status.error || status.message || "Conversion failed");
    }

    await new Promise((resolve) => setTimeout(resolve, 2000));
  }
}
```

## Node.js

Use this in a backend script. Keep API tokens on the server.

```js

const token = process.env.CONVERT3D_API_TOKEN;
const file = await openAsBlob("model.stl");

const form = new FormData();
form.append("file", file, "model.stl");
form.append("from", "stl");
form.append("to", "glb");

const createResponse = await fetch("https://api.convert3d.org/convert/jobs", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
  },
  body: form,
});

if (!createResponse.ok) {
  throw new Error(await createResponse.text());
}

const job = await createResponse.json();
console.log(job);
```

## Python

Use `requests` for scripts and backend jobs.

```py

token = os.environ["CONVERT3D_API_TOKEN"]
headers = {"Authorization": f"Bearer {token}"}

with open("model.stl", "rb") as file:
    create_response = requests.post(
        "https://api.convert3d.org/convert/jobs",
        headers=headers,
        files={"file": ("model.stl", file)},
        data={"from": "stl", "to": "glb"},
        timeout=300,
    )

create_response.raise_for_status()
job = create_response.json()

while True:
    status_response = requests.get(
        f"https://api.convert3d.org/convert/jobs/{job['id']}",
        headers=headers,
        timeout=30,
    )
    status_response.raise_for_status()
    status = status_response.json()

    if status["status"] == "success":
        print(status.get("signedUrl"))
        break

    if status["status"] == "failed":
        raise RuntimeError(status.get("error") or status.get("message"))

    time.sleep(2)
```

## React with model-viewer

This renders the converted GLB in [`<model-viewer>`](https://modelviewer.dev/) after conversion.

```tsx
"use client";

export function ConvertedModelViewer({
  file,
  apiToken,
}: {
  file: File;
  apiToken: string;
}) {
  const [modelUrl, setModelUrl] = useState<string | null>(null);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const script = document.createElement("script");
    script.type = "module";
    script.src = "https://unpkg.com/@google/model-viewer/dist/model-viewer.min.js";
    document.head.appendChild(script);
    return () => script.remove();
  }, []);

  useEffect(() => {
    let cancelled = false;

    convertModel(file, apiToken, "glb")
      .then((url) => {
        if (!cancelled) setModelUrl(url);
      })
      .catch((err) => {
        if (!cancelled) setError(err instanceof Error ? err.message : String(err));
      });

    return () => {
      cancelled = true;
    };
  }, [file, apiToken]);

  if (error) return <p>{error}</p>;
  if (!modelUrl) return <p>Converting...</p>;

  return (
    <model-viewer
      src={modelUrl}
      alt="Converted 3D model"
      auto-rotate
      camera-controls
      shadow-intensity="1"
      environment-image="neutral"
      style={{ width: "100%", height: 400 }}
    />
  );
}
```

## Plain HTML viewer

Use this after you have a converted model URL.

```html
<!doctype html>
<html>
  <head>
    <script
      type="module"
      src="https://unpkg.com/@google/model-viewer/dist/model-viewer.min.js"
    ></script>
  </head>
  <body>
    <model-viewer
      src="YOUR_CONVERTED_MODEL_URL"
      alt="3D model"
      auto-rotate
      camera-controls
      shadow-intensity="1"
      environment-image="neutral"
      style="width: 100%; height: 400px;"
    ></model-viewer>
  </body>
</html>
```

---

## GET /convert/jobs/:id

**URL:** https://docs.convert3d.org/docs/api-get-job
**Description:** Async job status

Use `GET /convert/jobs/:id` to check job status.

```txt
GET /convert/jobs/:id
```

Poll this endpoint after creating a job with [POST /convert/jobs](/docs/api-create-job).

## Path parameters

## Examples

### curl

```bash
curl https://api.convert3d.org/convert/jobs/job_123 \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

### JavaScript

```js
const token = process.env.CONVERT3D_API_TOKEN;
const jobId = "job_123";

const response = await fetch(`https://api.convert3d.org/convert/jobs/${jobId}`, {
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error(await response.text());
}

console.log(await response.json());
```

### Python

```py

job_id = "job_123"

response = requests.get(
    f"https://api.convert3d.org/convert/jobs/{job_id}",
    headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
    timeout=30,
)
response.raise_for_status()
print(response.json())
```

## Response fields

## Response examples

Queued:

```json
{
  "id": "job_123",
  "status": "queued",
  "progress": 0
}
```

In progress:

```json
{
  "id": "job_123",
  "status": "in_progress",
  "progress": 45,
  "message": "Converting model..."
}
```

Success:

```json
{
  "id": "job_123",
  "status": "success",
  "progress": 100,
  "message": "Completed",
  "signedUrl": "https://storage.convert3d.org/converted/model.glb?signature=..."
}
```

Failed:

```json
{
  "id": "job_123",
  "status": "failed",
  "progress": 0,
  "message": "Unsupported file format",
  "error": "Unsupported file format"
}
```

## Polling

Poll every 2-5 seconds. Stop when:

- `status` is `success`, then download the result.
- `status` is `failed`, then show or log the error.

---

## GET /health

**URL:** https://docs.convert3d.org/docs/api-health
**Description:** API availability check

Use `GET /health` to check that the API is reachable before sending conversion work.

```txt
GET /health
```

## Authentication

This endpoint uses the same bearer token header as other API requests.

## Examples

### curl

```bash
curl https://api.convert3d.org/health \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

### JavaScript

```js
const response = await fetch("https://api.convert3d.org/health", {
  headers: {
    Authorization: `Bearer ${process.env.CONVERT3D_API_TOKEN}`,
  },
});

if (!response.ok) {
  throw new Error(await response.text());
}

console.log(await response.text());
```

### Python

```py

response = requests.get(
    "https://api.convert3d.org/health",
    headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
    timeout=30,
)
response.raise_for_status()
print(response.text)
```

## Response

The response body is a small health response. Use HTTP status first:

- `2xx` means the API is reachable.
- `401` means the token is missing or invalid.
- `5xx` means the API could not serve the health check.

---

## API overview

**URL:** https://docs.convert3d.org/docs/api-overview
**Description:** Convert 3D files from your application

The Convert3D API converts 3D files from scripts, apps, and backend workflows.

Base URL:

```txt
https://api.convert3d.org
```

## Endpoints

| Method | Endpoint | Use when |
| --- | --- | --- |
| `GET` | [`/health`](/docs/api-health) | You want to check that the API is reachable. |
| `POST` | [`/convert`](/docs/api-convert) | You want one request that returns the converted file bytes. |
| `POST` | [`/convert/jobs`](/docs/api-create-job) | You want to start an async conversion job. |
| `GET` | [`/convert/jobs/:id`](/docs/api-get-job) | You want to check job status. |
| `GET` | [`/convert/jobs/:id/download`](/docs/api-download-job) | You want to download a completed job. |
| `GET` | [`/upload-url`](/docs/api-upload-url) | You want to upload a large file before creating a job. |

## Which flow should I use?

Use [`POST /convert`](/docs/api-convert) when:

- The file is small.
- You want the converted file in the same response.
- Your app can keep the request open until conversion finishes.

Use [`POST /convert/jobs`](/docs/api-create-job) when:

- The file is larger.
- You need status and progress.
- You want cleaner retries.
- The conversion runs inside a production workflow.

Use [`GET /upload-url`](/docs/api-upload-url) plus [`POST /convert/jobs`](/docs/api-create-job) when:

- Your app should upload the file before starting conversion.
- The file may be too large for a normal multipart request.
- You want a more reliable large-file workflow.

## Authentication

All cloud API requests require a bearer token.

```txt
Authorization: Bearer YOUR_API_TOKEN
```

Get an API token from [convert3d.org/convert3dapi](https://convert3d.org/convert3dapi).

## Common request fields

Most conversion requests use `multipart/form-data`.

## Examples

Endpoint pages include curl, JavaScript, and Python examples where they are useful.

Start with [Create a job](/docs/api-create-job) for production integrations.

---

## GET /upload-url

**URL:** https://docs.convert3d.org/docs/api-upload-url
**Description:** Large-file upload URL

Use `GET /upload-url` when you want to upload the source file before creating the conversion job.

```txt
GET /upload-url?file={filename}
```

This is the large-file flow:

1. Request an upload URL.
2. Upload the file with `PUT`.
3. Create a job with `POST /convert/jobs` using the returned `bucket` and `key`.

## Query parameters

## Step 1. Request an upload URL

### curl

```bash
curl "https://api.convert3d.org/upload-url?file=large-model.glb" \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

### JavaScript

```js
const token = process.env.CONVERT3D_API_TOKEN;
const fileName = "large-model.glb";

const response = await fetch(
  `https://api.convert3d.org/upload-url?file=${encodeURIComponent(fileName)}`,
  {
    headers: {
      Authorization: `Bearer ${token}`,
    },
  }
);

if (!response.ok) {
  throw new Error(await response.text());
}

const upload = await response.json();
console.log(upload);
```

### Python

```py

response = requests.get(
    "https://api.convert3d.org/upload-url",
    headers={"Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}"},
    params={"file": "large-model.glb"},
    timeout=30,
)
response.raise_for_status()
upload = response.json()
print(upload)
```

Response:

```json
{
  "uploadUrl": "https://storage.convert3d.org/uploads/...",
  "bucket": "uploads",
  "key": "uploads/abc123/large-model.glb"
}
```

## Step 2. Upload the file

Use the returned `uploadUrl` as a presigned `PUT` target.

### curl

```bash
curl -X PUT "$UPLOAD_URL" \
  --data-binary @large-model.glb
```

### JavaScript

```js

const bytes = await readFile("large-model.glb");

const uploadResponse = await fetch(upload.uploadUrl, {
  method: "PUT",
  body: bytes,
});

if (!uploadResponse.ok) {
  throw new Error(await uploadResponse.text());
}
```

### Python

```py
with open("large-model.glb", "rb") as file:
    upload_response = requests.put(upload["uploadUrl"], data=file, timeout=300)

upload_response.raise_for_status()
```

## Step 3. Create the conversion job

Send JSON to [POST /convert/jobs](/docs/api-create-job).

### curl

```bash
curl https://api.convert3d.org/convert/jobs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "bucket": "uploads",
    "key": "uploads/abc123/large-model.glb",
    "fileName": "large-model.glb",
    "from": "glb",
    "to": "usdz"
  }'
```

### JavaScript

```js
const createResponse = await fetch("https://api.convert3d.org/convert/jobs", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    bucket: upload.bucket,
    key: upload.key,
    fileName: fileName,
    from: "glb",
    to: "usdz",
  }),
});

if (!createResponse.ok) {
  throw new Error(await createResponse.text());
}

console.log(await createResponse.json());
```

### Python

```py
create_response = requests.post(
    "https://api.convert3d.org/convert/jobs",
    headers={
        "Authorization": f"Bearer {os.environ['CONVERT3D_API_TOKEN']}",
        "Content-Type": "application/json",
    },
    json={
        "bucket": upload["bucket"],
        "key": upload["key"],
        "fileName": "large-model.glb",
        "from": "glb",
        "to": "usdz",
    },
    timeout=30,
)
create_response.raise_for_status()
print(create_response.json())
```

## Notes

- The `bucket` value must match the bucket returned by `GET /upload-url`.
- The `key` value must match the uploaded object key.
- Poll and download the job the same way as any async job.

---

## Batch conversion

**URL:** https://docs.convert3d.org/docs/batch-conversion
**Description:** Several files, one output format

Batch conversion is for converting several files without repeating the same steps for each one.

## When to use batch conversion

Use batch conversion when:

- You have many files that need the same output format.
- You are preparing assets for a web viewer, game engine, CAD handoff, or marketplace upload.
- You want one download after all conversions finish.

## Convert multiple files

1. Open the converter.
2. Add all files that should use the same output format.
3. Include sidecar files such as `.mtl`, textures, or `.bin` files when the source format needs them.
4. Choose the output format.
5. Start conversion.
6. Download the converted files when the batch is done.

If the app bundles the results, the download is a zip file.

## Keep batches simple

Batch conversion works best when every main file is going to the same output format. If some files need different targets, split them into separate batches.

Examples:

- Convert several `.obj` files to `glb` for a web catalog.
- Convert several CAD files to `stl` for 3D printing review.
- Convert several game assets to `fbx` for a downstream tool.

## Sidecar files in a batch

Some files are not complete by themselves. For example, an `.obj` file may reference `.mtl` and image texture files.

When adding a batch:

- Keep each model's related files together.
- Add texture files at the same time as the main model when possible.
- Avoid renaming sidecar files before upload unless you also update the model references.

If a converted model has missing materials or textures, check the original source folder and convert again with the missing files included.

## Practical limits

- Keep related sidecar files with the main file.
- Split very large batches into smaller groups.
- Retry failed files individually instead of restarting files that already converted.
- Check the first converted result before using the same settings for a large batch.

---

## Geometry and quantization

**URL:** https://docs.convert3d.org/docs/compression-geometry
**Description:** Mesh cleanup and vertex precision

Geometry settings change the mesh data inside the GLB. Some changes are mostly cleanup. Quantization is different: it stores vertex data with less precision, which can make files smaller and can also change how the model looks.

## Geometry cleanup

Open **Advanced > Geometry** to control mesh cleanup.

![Geometry compression settings with Weld Vertices, Deduplicate accessors and textures, and Reorder for size enabled](/docs/compression/geometry-settings.png)

| Option | What it means | Turn it off when |
| --- | --- | --- |
| **Weld Vertices** | Merges identical vertices so shared geometry can be stored more efficiently. | The model shows unexpected seams or topology changes after compression. |
| **Deduplicate accessors/textures** | Removes duplicate GLB data such as repeated accessors, textures, meshes, and materials. | Rarely. This is usually safe. |
| **Reorder for size** | Reorders mesh data for better binary compression and transmission size. | Another app has trouble loading the compressed GLB. |

Unused data is pruned during compression even when no visible setting refers to it.

## Quantization

Open **Advanced > Quantization** to control how precisely vertex attributes are stored.

![Quantization settings for Position, Normal, Texcoord, Color, and Generic attributes](/docs/compression/quantization-settings.png)

Lower numbers usually make the file smaller. Higher numbers preserve more precision.

That tradeoff matters most for CAD-derived models. A tiny hole or sharp edge can be useful geometry, not decorative detail.

| Option | Range | Default | Controls | If too low |
| --- | --- | --- | --- | --- |
| **Position** | `8`-`16` | `14` | Vertex positions. | Edges, holes, or small CAD details may shift. |
| **Normal** | `6`-`12` | `8` | Surface normals used for lighting. | Surfaces may look faceted, wavy, or shaded incorrectly. |
| **Texcoord** | `8`-`16` | `12` | UV coordinates used to place textures. | Textures may smear or no longer line up with the model. |
| **Color** | `6`-`12` | `8` | Vertex colors. | Gradients or painted colors may show banding. |
| **Generic** | `8`-`16` | `12` | Other vertex attributes not covered above. | Custom data or tool-specific attributes may lose precision. |

## Common fixes

### Edges moved or small details disappeared

Increase **Position**. For CAD parts, use **Low** or set **Position** to `16`.

### The model looks faceted

Increase **Normal**. If the source file already had rough normals, convert again from the source and inspect the uncompressed GLB before compressing.

### Texture placement changed

Increase **Texcoord**. If the texture was already wrong before compression, check the original conversion and sidecar files.

### Another app rejects the GLB

Use **Low** first. If it still fails, disable **Reorder for size** and keep higher quantization values.

---

## Presets

**URL:** https://docs.convert3d.org/docs/compression-presets
**Description:** Low, Medium, and High compression

Start with a preset. Only open Advanced if the result looks wrong or you know exactly what you need to change.

![Compression preset choices for Low, Medium, and High](/docs/compression/presets.png)

The preset names describe compression strength, not file quality.

| Preset | Use when | What it changes |
| --- | --- | --- |
| **Low** | You need the safest visual result. | Uses lighter quantization, keeps larger textures, and does not reorder mesh data. |
| **Medium** | You want the normal first try. | Uses balanced geometry settings and resizes large textures to `2048px`. |
| **High** | You need a smaller file for upload, sharing, or mobile. | Uses stronger quantization, texture quality `70%`, and resizes large textures to `1024px`. |

## Exact preset values

| Setting | Low | Medium | High |
| --- | --- | --- | --- |
| Weld Vertices | On | On | On |
| Deduplicate accessors/textures | On | On | On |
| Reorder for size | Off | On | On |
| Position | 16 | 14 | 12 |
| Normal | 10 | 8 | 8 |
| Texcoord | 14 | 12 | 10 |
| Color | 10 | 8 | 8 |
| Generic | 14 | 12 | 10 |
| Texture format | WebP | WebP | WebP |
| Texture quality | 90% | 80% | 70% |
| Texture max resolution | 4096px | 2048px | 1024px |

## What to try first

| Goal | Start with |
| --- | --- |
| Safe first attempt | **Medium** |
| Preserve CAD edges and small holes | **Low** |
| Small web preview | **High** |
| Product model with labels | **Medium**, then raise texture quality if needed |
| Transparent material or cutout texture | WebP or PNG. Avoid JPEG. |
| Target app rejects the GLB | **Low**, then disable **Reorder for size** |

## If the preset is too aggressive

Use a lighter preset first.

If that still changes too much:

- Raise **Position** if edges, holes, or CAD details moved.
- Raise **Normal** if lighting looks faceted.
- Raise **Texture Quality** or **Max Resolution** if textures look blurry.
- Disable **Reorder for size** if another app stops opening the GLB.

---

## Texture compression

**URL:** https://docs.convert3d.org/docs/compression-textures
**Description:** WebP, JPEG, PNG, quality, and max resolution

Texture compression can save a lot of space. It can also make a good model look cheap very quickly. Watch labels, decals, logos, and transparent areas.

Open **Advanced > Texture** to control image compression.

![Texture compression settings with WebP format, quality slider, and 2048px max resolution](/docs/compression/texture-settings.png)

## Enable texture compression

When enabled, Convert3D re-encodes supported texture images.

Normal maps are skipped when their names include `normal` or `nrm`. Normal maps are not ordinary images. Compress them aggressively and lighting can start looking wrong.

Disable texture compression when:

- you need exact texture pixels
- fine labels, linework, or decals become blurry
- you plan to process textures in another tool

## Format

| Format | Use when | Notes |
| --- | --- | --- |
| **WebP** | You want a good default for web use. | Supports transparency and usually gives smaller files than PNG. |
| **JPEG** | Textures are fully opaque and file size matters most. | Does not support alpha. Transparent pixels become white. |
| **PNG** | You need lossless output or exact transparency. | The quality slider does not work like WebP or JPEG. Files may be larger. |

## Quality

Quality controls lossy image compression for WebP and JPEG.

| Range | Use when |
| --- | --- |
| `90%`-`100%` | Text, labels, decals, UI panels, or inspection assets. |
| `75%`-`85%` | Most product models and web previews. |
| `50%`-`70%` | Small files matter more than texture detail. |

If the file size barely changes, textures may already be small, the model may be geometry-heavy, or PNG may be preserving more data than expected.

## Max Resolution

Max Resolution limits the longest side of each texture.

| Setting | Use when |
| --- | --- |
| **No limit** | You need to preserve source texture dimensions. |
| **512px** | Small previews, thumbnails, or very small embedded models. |
| **1024px** | Mobile-first sharing and small files. |
| **2048px** | Balanced web display. |
| **4096px** | Close inspection or high-quality product detail. |

Downscaling only applies when a texture is larger than the selected limit.

## Common fixes

### Textures are blurry

Increase **Texture Quality** and **Max Resolution**. For labels, decals, and line art, use PNG or high-quality WebP.

### Transparent areas turned white

Use WebP or PNG. JPEG has no alpha channel, so Convert3D fills transparent pixels with white when writing JPEG textures.

### The file is still large

If textures dominate the file size, lower **Max Resolution** or use WebP/JPEG. If geometry dominates, texture settings will not do much.

---

## Compression

**URL:** https://docs.convert3d.org/docs/compression
**Description:** Make GLB files smaller without breaking the model

Compression is for `.glb` files that already work.

Use it after the model converts and previews correctly. If the model is broken before compression, compression will mostly give you a smaller broken model. Efficient, technically. Not useful.

## Compress a GLB

Open [convert3d.org/app/compress](https://convert3d.org/app/compress), upload a model, choose a preset, and click **Compress**.

![Compression app with model preview and advanced compression settings](/docs/compression/full-compression-app.png)

Convert3D keeps the model visible while you change settings. Check it before and after compression.

![Compression settings sidebar with Low, Medium, and High presets](/docs/compression/settings-sidebar.png)

## What compression can change

Convert3D can:

- Remove unused GLB data.
- Deduplicate repeated data.
- Weld identical vertices.
- Reorder mesh data for smaller output.
- Quantize vertex attributes.
- Resize and re-encode textures.

Convert3D does not:

- Reduce triangle count by decimating the mesh.
- Remesh or retopologize the model.
- Bake materials into texture atlases.
- Convert textures to KTX2/Basis.
- Add Draco mesh compression.

If the model has too many polygons, simplify it in the source tool first, then convert or compress the resulting GLB.

## Where to go next

| If you need to... | Read |
| --- | --- |
| Pick Low, Medium, or High | [Presets](/docs/compression-presets) |
| Fix faceted shading, shifted edges, or precision loss | [Geometry and quantization](/docs/compression-geometry) |
| Reduce texture size or fix blurry textures | [Texture compression](/docs/compression-textures) |

## Compare the result

After compression, inspect the model before replacing the original file. A smaller file only helps if the model still looks right.

![Before and after compression comparison of a chair model](/docs/compression/before-after-preview.png)

Look for:

- blurry textures
- shifted edges or tiny holes
- faceted lighting
- missing parts
- target apps that no longer open the GLB

If something changed too much, click **Adjust**, use a lighter preset, and compress again.

## Download or keep working

The result screen shows the original size, compressed size, and percentage saved.

![Compression size summary showing original and compressed file sizes](/docs/compression/size-summary.png)

Download the compressed GLB when it looks right. You can also send the result to Convert, Render, View, or Transfer.

![Compression Complete screen with Download, Adjust, Start over, and continue actions](/docs/compression/compression-complete.png)

## If compression fails

### The file is not GLB

The compressor expects a `.glb` input. Convert the source model to GLB first, then compress that GLB.

### The result is larger than the original

This can happen when the input was already optimized, or when lossless texture output stores more data than the original. Try WebP, lower texture resolution, or keep the original file.

---

## Conversion

**URL:** https://docs.convert3d.org/docs/conversion
**Description:** Convert a 3D file in the Convert3D web app

You may arrive here with a file that opens in one app and refuses to open in the next one. Or you found a nice model online, but it’s in a format you don’t know. Or, you’re working with someone and they say stuff like “I’ll need an STL, buddy”, or maybe they say “you have to do a FBX with all materials inside”. It’s a jungle, honestly. But we will do our best to have you covered. And if we don’t, reach out! 

At Convert3D we sit in the middle: upload the file you have, choose the format the next tool (or person!) wants, and check what came out.

## Convert one file

1. Open [convert3d.org/convert][1].
2. Drop the file on the upload area, or choose it from your computer.
3. Choose the format you need.
4. Download the converted file.

Convert3D reads the source format from the filename extension. If it does not recognize the file, check that first. Renaming `model.fbx` to `model.obj` does not make it an OBJ file. Annoying, but true.

If you close the page before downloading, run the conversion again. The web app is built around the current conversion result, not a file manager of old conversions.

## Check the preview before trusting the file

The preview is your first answer. If Convert3D understood the source file, the preview should show the model you expected.

This is where you check if everything is alright:

- Yes, the model loads.
- Yes, the model is facing the right way.
- Important parts are not missing.
- Materials or textures are there and they look great.
- The model has the right size.

If the preview is already wrong, downloading another final format usually will not fix it. But give it a shot, just to be sure. Try again with the missing sidecar files (in a zip, or just drag everything in), check the source in the app that made the model, or pick a target format that fits the data better.

## Pick the format the next app wants

This is where a lot of failed conversions start. The source file may be fine. The target format may simply be the wrong one.

| If you need to...                 | Try                    | Notes                                                                                                                        |
| --------------------------------- | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Show the model on the web         | `glb`                  | Good default. One single file with geometry, materials, and textures. And we can optimize it and make it faster and smaller! |
| Open in Apple AR Quick Look       | `usdz`                 | Use this for iPhone and iPad AR previews. ZIP compressed by default.                                                         |
| Check a part for 3D printing      | `stl` or `3mf`         | `stl` is geometry-only. Materials will not come with it. But if you’re printing, you are most likely ok with that.           |
| Move between DCC or game tools    | `fbx`, `obj`, or `glb` | Use whatever the next app imports best.                                                                                      |
| Move CAD data to another CAD tool | `stp`                  | Usually better than mesh formats when CAD solids matter.                                                                     |
| Send a DWG or DXF                 | `dwg` or `dxf`         | Decide whether you need a 3D mesh or a 2D drawing. Confusingly, these formats can contain both or one or the other.          |
| Use Roblox Studio                 | `rbxm` or `rbxl`       | Use these when Roblox is the target. (If it doesn’t work, blame John)                                                        |

When in doubt, try `glb` first. It is a good intermediate format for many tasks, and one of the most modern and compatible ones. The industry folks really likes it so it’s making its way into more and more apps as we speak. 

## If the target software will not open it

This is one of the most common problems: Convert3D creates a file, but the next app refuses to open it.

Check the boring things first:

- Did you choose the exact format the target app asks for?
- Does the target app support that format version?
- Did the source model already look right in the preview?
- Are you sending a mesh to a tool that expects CAD solids?
- Are you sending a 2D drawing where the app expects a 3D model?

If the target app gives you a vague error, convert to `glb` and inspect the model first. If the GLB looks right, the issue is probably the target format or the target app. If the GLB looks wrong, go back to the source file.

## STL is not a CAD solid

STL is a mesh format. It is made of triangles.

That matters if you are trying to turn a messy STL into a clean CAD file. Converting `stl` to `stp` or another CAD format may help a tool import the file, but it will not recreate the original editable solid model. The original CAD surfaces are already gone.

If CAD solids matter, start from `step`, `stp`, `sldprt`, `sldasm`, or another CAD source format when you can. If all you have is STL, inspect the result carefully in the target CAD app.

## Bring the files that belong together

Some formats travel as a small pile of files.

`obj` is the usual offender. The `.obj` file may contain the geometry, while the `.mtl` file describes the materials and separate image files hold the textures. Upload only the OBJ and you may get the shape, but not the surface. It is like moving house and leaving the furniture behind.

`gltf` can also point to external `.bin` files and textures. Some CAD and scene formats reference linked assets too.

If textures disappear after conversion, look for missing files before trying a different output format.

## Batch similar files

Batch conversion works best when the files want the same treatment.

Ten `obj` files to `glb` is a good batch. A folder of CAD parts to `stl` is fine too. A mixed folder where some files need `glb`, others need `dwg`, and half the textures are missing is not a batch. That is a small cleanup project.

Use [batch conversion][2] after you have tested one file and know the settings are right.

## Be careful with DWG and DXF

DWG and DXF are awkward because they can contain 2D drawings, 3D models, or both. The extension alone does not tell you enough.

When DWG or DXF is the output format, Convert3D can write:

- `3D / Mesh` for a 3D object.
- `2D / Multiview drawing` for front, top, and right-side drawing views.

If you expected a 3D object and got a flat drawing, check the output mode. If you expected a drawing and got a mesh, choose `2D / Multiview drawing`.

See [DWG and DXF][3] for the longer checklist.

## If textures are missing

Start with the boring causes. They are usually the right ones.

- The source format may not store textures.
- The target format may not support the same material features.
- The source file may reference texture files that were not uploaded.
- An `.obj` file may be missing its `.mtl` file.

For web display, try `glb`. It keeps the model, materials, and textures together in one file.

## If conversion fails

Usually it is one of these:

- The source format is not supported.
- The target format is not supported for that source.
- The file extension is wrong.
- The source file is damaged.
- Sidecar files are missing.
- The source uses features the target format cannot represent.

Open the source file in the app that created it. If it does not open there, Convert3D probably cannot read it either.

See [Troubleshooting][4] for fixes.

[1]:	https://convert3d.org/convert
[2]:	/docs/batch-conversion
[3]:	/docs/dwg-dxf
[4]:	/docs/troubleshooting

---

## DWG and DXF

**URL:** https://docs.convert3d.org/docs/dwg-dxf
**Description:** 2D drawings and 3D CAD files

DWG and DXF are CAD formats that can carry 2D drawing data, 3D model data, annotations, layers, and metadata. That makes them useful, but it also makes them easy to misread during conversion.

If a DWG or DXF conversion does not look right, first decide whether the file should be treated as a 2D drawing or a 3D model.

## Choose the right result

| Goal | Choose |
| --- | --- |
| Open the result as a 3D model | `3D / Mesh` |
| Send a drawing to CAD, CNC, laser cutting, or review workflows | `2D / Multiview drawing` |
| Keep textures and materials | Convert to `glb`, not DWG/DXF. |
| Preserve exact editable CAD features | Use the original CAD tool when possible. Conversion may turn features into meshes or lines. |

## Convert3D output modes

When DWG or DXF is the output format, Convert3D can write two kinds of result.

| Mode | What it writes | Use when |
| --- | --- | --- |
| **3D / Mesh** | 3D mesh geometry in DWG or DXF. | The next tool expects a 3D object. |
| **2D / Multiview drawing** | Orthographic line drawings from the converted 3D model. | The next tool expects a 2D drawing. |

The **View** switch appears in the download sidebar after a successful conversion when DWG or DXF supports both modes.

## 2D multiview drawings

`2D / Multiview drawing` creates a drawing from the converted 3D model.

It includes:

- Front view.
- Top view.
- Right-side view.
- A third-angle projection layout.
- Separate drawing layers for the generated views.

It does not recreate:

- Original title blocks.
- Original dimensions.
- Original text annotations.
- Parametric CAD features.
- Hidden manufacturing intent that was not present in the converted model.

Use this mode when you need a readable drawing from a 3D model. Do not expect it to be the same as a hand-authored engineering drawing.

## 3D mesh output

`3D / Mesh` writes the model as mesh geometry. This is the right choice when another CAD or 3D tool should receive a 3D object.

Mesh output is different from editable solid CAD:

- Curved CAD surfaces may become tessellated faces.
- Materials may not map exactly.
- Textures are not the main strength of DWG or DXF.
- Downstream CAD tools may show mesh objects differently from native solids.

If the target workflow needs clean solids, try `step` or `stp` instead of DWG/DXF.

## When importing DWG or DXF

A DWG or DXF file may be mostly 2D drafting data, mostly 3D geometry, or a mix of both. Convert3D can only convert what it can read as usable geometry.

Check the source file:

- Does it open correctly in the CAD app that created it?
- Is the important content in model space, paper space, or an external reference?
- Is the content made of geometry, or mostly dimensions, text, hatches, images, and annotations?
- Is it a 2D floor plan being converted to a 3D model format?
- Is it a 3D model being exported to a 2D drawing format?

If a 2D drawing is converted to a 3D mesh format such as `stl`, it may look flat or empty because there is no 3D solid to export.

## Common problems

### The output is flat

The source may be a 2D drawing, or the selected output mode may be `2D / Multiview drawing`.

If you need a 3D model, choose `3D / Mesh` and confirm the source file contains 3D geometry.

### The output is 3D, but I expected a drawing

Choose `2D / Multiview drawing` in the download sidebar after conversion. Convert3D will regenerate the DWG/DXF as front, top, and right-side views.

### Text, dimensions, or hatches are missing

Many conversion pipelines prioritize geometry. Text, dimensions, hatches, xrefs, and tool-specific CAD objects may not survive as editable entities.

If those annotations are the important part of the file, open the source in the CAD app that created it and export a drawing-focused format from there.

### The model looks faceted

Curved CAD surfaces can become tessellated mesh faces during conversion. For solid CAD exchange, try `step` or `stp`. For web preview, use `glb` and inspect the model before exporting to DWG/DXF.

### Scale or origin is wrong

CAD files often rely on units, model origin, and drawing setup from the source application. Open the original file and check units, origin, and whether geometry is far from the drawing origin.

## Debug checklist

1. Open the source file in the app that created it.
2. Confirm whether the important content is 2D drawing data or 3D model geometry.
3. Convert to `glb` first and inspect the model in the viewer.
4. If the GLB looks correct, convert the result to DWG or DXF.
5. Choose `3D / Mesh` or `2D / Multiview drawing` based on the next tool.
6. If annotations are missing, export from the source CAD app when possible.

## Related pages

- [Supported formats](/docs/formats)
- [Conversion](/docs/conversion)
- [Troubleshooting](/docs/troubleshooting)

---

## Supported formats

**URL:** https://docs.convert3d.org/docs/formats
**Description:** Input and output formats supported by Convert3D

Convert3D supports many import formats and a smaller set of export formats. Import support means Convert3D can read the file. Export support means Convert3D can write that format as the final result.

## Common conversions

| From | To | Notes |
| --- | --- | --- |
| `obj` | `glb`, `fbx`, `stl`, `usdz` | Include `.mtl` and textures when available. |
| `fbx` | `glb`, `obj`, `stl`, `usdz` | Good for game and DCC workflows. |
| `stl` | `glb`, `obj`, `fbx` | STL has geometry only, not materials. |
| `step`, `stp` | `glb`, `stl`, `obj`, `dxf`, `dwg` | Useful for CAD-to-web and CAD-to-mesh flows. |
| `glb`, `gltf` | `usdz`, `obj`, `fbx`, `stl` | Good source formats for web assets. |
| `dwg`, `dxf` | `glb`, `stl`, `obj`, `dxf`, `dwg` | Choose 3D mesh or 2D multiview output based on the next tool. |

## Import formats

`3d`, `3dm`, `3ds`, `3mf`, `ac`, `ac3d`, `acc`, `amf`, `amj`, `ase`, `ask`, `b3d`, `blend`, `brep`, `bvh`, `cob`, `csm`, `dae`, `dwg`, `dxf`, `enff`, `fbx`, `gcode`, `glb`, `gltf`, `hmb`, `ifc`, `iges`, `igs`, `iqm`, `irr`, `irrmesh`, `lwo`, `lws`, `lxo`, `m3d`, `max`, `md2`, `md3`, `md5`, `mdc`, `mdl`, `mot`, `ms3d`, `nc`, `ndo`, `nff`, `obj`, `off`, `ogex`, `ply`, `pmx`, `prj`, `q3o`, `q3s`, `raw`, `rbxl`, `rbxm`, `scn`, `sib`, `sldasm`, `slddrw`, `sldprt`, `smd`, `step`, `stl`, `stp`, `ter`, `uc`, `usd`, `usda`, `usdc`, `usdz`, `vox`, `vta`, `x`, `x3d`, `xgl`, `xml`, `zgl`

## Export formats

`3dm`, `3ds`, `3mf`, `dae`, `dwg`, `dxf`, `fbx`, `glb`, `gltf`, `obj`, `ply`, `rbxl`, `rbxm`, `stl`, `stp`, `usdz`, `x`

## Format notes

- **GLB** is usually the best format for web display because it stores geometry, materials, and textures in one binary file.
- **USDZ** is commonly used for Apple AR workflows.
- **STL** is geometry-only. Materials and textures are not preserved.
- **OBJ** often needs sidecar `.mtl` and texture files.
- **STEP/STP** is useful for CAD exchange, but some CAD features may become mesh geometry when exported to model formats.
- **DWG/DXF** can represent 2D and 3D data. See [DWG and DXF](/docs/dwg-dxf) before debugging a flat, empty, or unexpected CAD result.

---

## Welcome to Convert3D

**URL:** https://docs.convert3d.org/docs
**Description:** Convert, view, render, compress, and automate 3D files

**Convert3D** is a set of tools for working with 3D files in the browser and through an API. Use it to convert models between common formats, inspect files, create rendered images, reduce GLB size, and generate 3D models from images or text.

  
  
  

## What you can do

- **Convert models.** Upload a 3D file and download another format such as GLB, OBJ, FBX, STL, USDZ, STEP, DWG, or DXF.
- **View and inspect models.** Rotate, zoom, switch render modes, inspect scene nodes, and check material or texture details.
- **Compress GLB files.** Reduce geometry and texture size while keeping the file usable for web viewers.
- **Render models.** Generate PNG images from 3D files using a standard renderer or AI-assisted render flow.
- **Generate 3D models.** Create GLB files from an image or text prompt.
- **Automate conversions.** Use the API for sync conversions, async jobs, and upload-first workflows.

---

## Privacy and processing

**URL:** https://docs.convert3d.org/docs/privacy
**Description:** Where files are processed

Convert3D has different processing paths depending on the feature.

## Browser-based tools

Viewing, standard conversion flows, and compression are designed to do as much work as possible in the browser. This keeps common workflows fast and reduces unnecessary upload handling.

## API conversions

API conversions are server-side. Your file is sent to the Convert3D API so it can be converted and returned or stored for download.

## AI features

AI rendering and AI 3D generation use external model providers. These workflows may upload source images, model previews, prompts, or generated outputs to complete the request.

Use AI features only for files and prompts that are acceptable for that processing path.

## Sharing and downloads

When a workflow creates a download URL, treat it like a private link. Anyone with the link may be able to access the file until the link expires or storage policy removes it.

---

## Quickstart

**URL:** https://docs.convert3d.org/docs/quickstart
**Description:** Convert your first file in the web app

This guide covers the fastest path through the Convert3D web app.

## Convert a file

  
  
  
  

## Pick the right output

Choose the output format based on where the file goes next.

| Goal | Start with |
| --- | --- |
| Display the model on the web | `glb` |
| Use Apple AR Quick Look | `usdz` |
| Send to a 3D printing tool | `stl` or `3mf` |
| Move between 3D apps | `fbx`, `obj`, or `glb` |
| Exchange CAD data | `stp`, `dwg`, or `dxf` |

## If your model has textures

Upload related files together. OBJ files often need a `.mtl` file and texture images. glTF files may need a `.bin` file and texture images.

For the simplest web output, convert to `glb`. GLB can package geometry, materials, and textures into one file.

## Convert several files

Use [batch conversion](/docs/batch-conversion) when several files should use the same output format.

## Next steps

- Read [conversion basics](/docs/conversion) before choosing formats.
- Check [supported formats](/docs/formats) for import and export support.
- Read the [API overview](/docs/api-overview) if you want to automate conversions.

---

## Rendering

**URL:** https://docs.convert3d.org/docs/rendering
**Description:** Create PNG images from 3D models

Use rendering when you need an image of a 3D model instead of another 3D file.

This is for product shots, architecture previews, marketplace images, internal reviews, or the familiar "can you make this model look nicer?" request.

## Upload a model

Open [convert3d.org/render-model](https://convert3d.org/render-model) and upload a supported 3D file.

![Render upload area with Select 3D model files button](/docs/rendering/upload-dropzone.png)

If you do not have a model ready, use one of the sample models below the upload area.

For predictable renders:

- Use `glb` when possible.
- Check that textures are included.
- Use a model that is already centered and scaled reasonably.
- Inspect CAD or scan files before spending time on render settings.

## Move the camera

The camera view is part of the render. If the model looks good from the wrong angle, the render will also be from the wrong angle. Annoying, but at least easy to fix.

![3D model render view with camera toolbar and orientation cube](/docs/rendering/model-camera-controls.png)

Use the camera toolbar to reset, fit, pan, zoom, orbit, walk in first person, or explode the model.

![Camera toolbar with Home, Fit, Pan, Zoom, Orbit, 1st person, and Explode](/docs/rendering/camera-toolbar.png)

The cube shows the current orientation.

![Orientation cube showing back and left faces](/docs/rendering/orientation-cube.png)

## Choose render mode, size, and shape

The controls at the top of the prompt area choose the render path, output size, and aspect ratio.

![Render controls showing AI mode, 2K size, and Auto aspect ratio](/docs/rendering/output-toolbar.png)

- **AI** uses the prompt and presets to create a styled render.
- **2K** controls output size.
- **Auto** lets the render choose the aspect ratio from the current view or preset.

Use standard rendering when you want a direct image of the current model view. Use AI rendering when you want the model restyled, relit, or placed into a more finished scene.

## Preserve the camera angle

Turn on **Preserve camera angle** when the current model view matters.

![Preserve camera angle toggle](/docs/rendering/preserve-camera-angle.png)

This is useful when you already framed the model and only want the render style to change. Turn it off when the preset can choose a better camera angle.

## Use presets

Presets are the fastest way to get a specific look without writing a long prompt.

![Choose a Preset dialog with Enhancement, Architecture, and Product categories](/docs/rendering/preset-picker.png)

Pick a category, then choose a preset. The preset fills in the style direction for the render.

After choosing a preset, you can still adjust the parts that matter.

![Luxury Premium preset settings with product photography, spotlight, bokeh, and tone options](/docs/rendering/preset-settings.png)

Some preset fields are menus. For example, visual effects can use bokeh, lens flare, particles, reflections, glow, or a custom value.

![Preset effects dropdown with bokeh, lens flare, particles, reflections, glow, and custom options](/docs/rendering/effects-dropdown.png)

## Write the prompt

Use the prompt box for the part the preset does not know.

Good prompts are specific:

- `leather chair with classic scandinavian wood`
- `white ceramic teapot on a marble counter`
- `small cabin at dusk, warm interior lights`

Short is fine. The prompt does not need to sound like a photoshoot brief.

![Render button with remaining render count](/docs/rendering/render-button.png)

If the render button shows a number, that is your remaining render count.

## Edit an existing render

After a render is finished, you can use it as a reference image and ask for a change.

![Reference image thumbnail added to the render prompt](/docs/rendering/reference-thumbnail.png)

When an image is being edited, the prompt area shows **Editing image**.

![Editing image pill](/docs/rendering/editing-image-pill.png)

Describe what should change.

![Prompt box asking how to change the selected render](/docs/rendering/editing-prompt.png)

Examples:

- `make the wood lighter`
- `add warm window light`
- `remove the background`
- `make it look like high-end product photography`

## Download the render

When the render is ready, download the image.

![Download button for a completed render](/docs/rendering/download-render.png)

If you do not like the result, keep the same model and adjust one thing at a time: camera, preset, prompt, or reference image. Changing all of them at once makes it harder to know what helped.

## Common problems

### The render is from the wrong angle

Move the camera first, then render again. Turn on **Preserve camera angle** if the AI render keeps choosing a different view.

### The model looks washed out

Try a different preset or lighting option. If the source file came from CAD, it may not have useful materials.

### Textures are missing

Check the source file. `obj` files often need `.mtl` and texture files. `gltf` files may need `.bin` and texture files.

For rendering, `glb` is usually the easiest source format because it keeps the model and textures together.

### The AI result changes too much

Use a shorter prompt, keep **Preserve camera angle** on, and use the existing render as a reference image.

### The render button is disabled

Check that a model is loaded and that the render settings are complete. AI rendering may also require sign-in and available render credits.

---

## Sharing

**URL:** https://docs.convert3d.org/docs/sharing
**Description:** Create a review link for a 3D model

Use Sharing when someone needs to look at - or use - a 3D model you have. They don’t need a 3D app to view the model, and they can download whatever format they need. You don’t need to convert the model first. 

This is great for reviews, approvals, and quick handoffs. If the other person needs to edit the source file, just share the original project files.

## My transfers

Your transfers page shows links you have created before, including expired ones.

![My transfers page with a new transfer tile and expired transfers][image-1]

Expired transfers are no longer available to the recipient. Create a new transfer if someone needs access again.

## Create a transfer

Start a new transfer, then add a title and message that explain what the recipient should check.

![New transfer form with email, title, message, expiration, and get link button][image-2]

The title and message appear on the shared preview page. Use them for the thing the reviewer actually needs to decide, not for internal notes.

![New transfer form filled with title and message][image-3]

Good examples:

- `New model for approval`
- `Check the scale before we send this to print`
- `Does the material look right on the helmet?`
- `As agreed, a new model of the trashcans for the beach`

Less useful:

- `File`
- `Test`
- `Here`

## Set an expiration

Choose how long the link should work.

![Transfer expiration menu with 1 day, 3 days, 7 days, 30 days, 60 days, and 1 year][image-4]

Use shorter links for quick review. Use longer links only when the recipient really needs time to come back to the file.

If a transfer expires, the recipient cannot use the old link anymore. Make a new transfer instead of sending the old link again.

## Add a password when needed

Password protection is useful when the link may be forwarded, pasted into a ticket, or shared outside a small group. In general, shares are kind of secret because their URLs are unguessable. The password adds an extra layer of safety.

![Password protect popover with a password field][image-5]

Send the password separately from the link. For example, send the link in email and the password in chat, or deliver it over a nice cup of coffee.

## Create the link

After you click **Get a link**, Convert3D creates the transfer.

![New transfer dialog creating a transfer][image-6]

When it is ready, copy the link or open the preview yourself before sending it.

![Transfer created dialog with copy link and explore preview buttons][image-7]

Opening the preview is worth doing once. It catches the boring but real mistakes: wrong model, wrong message, expired too soon, or missing material.

## What the recipient sees

The recipient opens a preview page with the model, your title, your message, and the file count.

![Shared model preview page with title, message, copy link, and download GLB button][image-8]

They can inspect the model in the browser. If downloads are available for the transfer, they can download the GLB from the preview page.

## When sharing is the wrong tool

Use conversion instead if the other person needs a different file format.

Use compression first if the model is too large for the recipient's tool, website, or upload limit.

Use the original source files if the recipient needs to edit the model with all project data intact.

[image-1]:	/docs/sharing/my-transfers.png
[image-2]:	/docs/sharing/new-transfer-form.png
[image-3]:	/docs/sharing/transfer-details.png
[image-4]:	/docs/sharing/expiry-menu.png
[image-5]:	/docs/sharing/password-protect.png
[image-6]:	/docs/sharing/creating-transfer.png
[image-7]:	/docs/sharing/transfer-created.png
[image-8]:	/docs/sharing/shared-preview.png

---

## Troubleshooting

**URL:** https://docs.convert3d.org/docs/troubleshooting
**Description:** Fix common Convert3D issues

Use this page to diagnose common problems.

## Conversion fails

Check:

- The input format is supported.
- The output format is supported.
- The file extension matches the actual file type.
- Required sidecar files are included.
- The source file opens in the app that created it.

If the extension is wrong, rename the file to the correct extension and try again.

## Textures are missing

Common causes:

- OBJ was uploaded without its `.mtl` file.
- Texture image files were not uploaded with the model.
- The source file uses absolute local paths.
- The target format does not support the same material features.

For web display, try converting to `glb` because it can contain textures in one file.

## The model looks wrong after conversion

Check scale, orientation, and material support. Some source formats store scene data that does not map cleanly to every output format.

Try converting to `glb` first and inspect the model in the viewer.

## DWG or DXF output is not what I expected

First decide whether the next app expects a 3D object or a 2D drawing.

- Use `3D / Mesh` when the result should stay a 3D model.
- Use `2D / Multiview drawing` when the result should be front, top, and right-side drawing views.
- Use `step` or `stp` when the next app needs solid CAD exchange more than DWG/DXF.

See [DWG and DXF](/docs/dwg-dxf) for the full checklist.

## Compression says the file is not GLB

The compressor expects a GLB file. Convert the model to `glb` first, then compress the GLB.

## AI generation fails

Check:

- You are signed in.
- Your account has credits or available usage.
- The input image is clear enough for 3D generation.
- The prompt is specific and does not ask for incompatible details.

For image-to-3D, use a clear image with the main object visible.

---

## Materials and wireframe

**URL:** https://docs.convert3d.org/docs/viewing-materials
**Description:** Debug surface data, transparency, and mesh density

Use this page when the model opens, but the result does not look right.

The important question is usually not "can I see the model?" It is what kind of problem you are looking at: a material problem, a missing texture problem, or a geometry problem.

## First split the problem

Switch between **Material** and **Wireframe**.

![View mode menu with Material and Wireframe options](/docs/viewing/material-wireframe-menu.png)

If Material view looks wrong but Wireframe looks reasonable, the geometry probably imported and the issue is surface data.

If Wireframe is extremely dense, tangled, or missing parts, the issue is probably geometry. Materials will not fix that.

## Material view

Material view shows the surface data Convert3D can read from the file.

![Submarine model in material view](/docs/viewing/material-view.png)

Look for these clues:

- A model that is all white usually lost textures, material files, or vertex colors.
- A model that has basic colors but no realistic surface may have imported CAD colors, not render materials.
- A transparent part that turns solid usually has missing alpha data or an unsupported material setup.
- A metallic part that looks flat may have lost roughness, metalness, or environment-dependent lighting.

If it is wrong here, converting the file to another format usually carries the wrong result forward. Fix the source export or include the missing sidecar files first.

## Wireframe view

Wireframe view shows the triangle structure behind the surface.

![Submarine model in wireframe view](/docs/viewing/wireframe-view.png)

Use it to answer questions that Material view hides:

- Is this one object, or several meshes sitting on top of each other?
- Did a CAD model become a very dense triangle mesh?
- Are small details real geometry, or are they only textures?
- Is the model heavy because of one part, or because everything is dense?

Dense wireframe is not automatically bad. CAD, scans, and sculpted models can be dense for good reasons. It becomes a problem when the target app has upload limits, slow loading, or mobile performance requirements.

## Read the material panel

Select a node to see the material values stored on that part.

![Selected mesh panel with material properties](/docs/viewing/selected-mesh-material.png)

The useful fields are:

| Field | What it tells you |
| --- | --- |
| `Color` | The base material color. If this is white but the original was textured, the texture may be missing. |
| `Metalness` | `0` is non-metal, `1` is fully metallic. Values in between are common after conversion, but may not match every renderer. |
| `Roughness` | Lower values look glossier. Higher values look more matte. |
| `Opacity` | `1` is opaque. Lower values need transparency support in the target app. |
| `Transparent` | Whether the material is treated as transparent, not just whether opacity is below `1`. |
| `Emissive` | A color that appears self-lit. Some target apps ignore this. |
| `Side` | Whether faces render from the front, back, or both sides. Thin surfaces can disappear if this is front-only. |

The material name is usually less important than the values. Names like `wire_086086086` or `Material_31` often come from the exporter. Messy names do not mean the material failed.

## Common source format problems

Start here before changing settings at random:

- `obj` needs the `.obj`, `.mtl`, and texture images together. Uploading only the `.obj` often gives you plain geometry.
- `gltf` can reference a `.bin` file and external textures. Missing one of those can make the model load without the expected materials.
- `glb` is usually safer for web use because it can keep geometry, materials, textures, and binary data in one file.
- `stl` is mostly geometry. Do not expect normal material data from it.
- CAD formats often bring over part colors, not full render materials. That can be enough for inspection, but not enough for product rendering.

## What to try next

If textures are missing, re-export as `glb` or upload the full set of sidecar files.

If the mesh is too dense, try [Compression](/docs/compression) and check the result in Wireframe again.

If a part disappears from one side, check `Side` first. A double-sided material may be needed in the target app.

---

## Scene hierarchy

**URL:** https://docs.convert3d.org/docs/viewing-scene-hierarchy
**Description:** Select objects, meshes, and geometry inside a 3D file

Most 3D files are not one clean object.

They can contain a root scene, empty nodes, object groups, meshes, geometry, materials, cameras, and whatever naming scheme the source app decided to export that day. The scene tree shows that structure.

## Use the tree

The tree is most useful when the canvas does not tell the whole truth.

A file can have visible objects, empty wrapper nodes, nested groups, and many meshes with similar names. Open the tree when you need to know where the geometry actually lives.

![Scene hierarchy showing objects and a selected geometry node](/docs/viewing/scene-tree.png)

Select a mesh or geometry node to highlight it in the viewer.

![Selected model part highlighted in the viewer](/docs/viewing/selected-object.png)

This helps when:

- the file has many parts
- the model looks empty but may have geometry in a child node
- one product part or CAD assembly piece needs to be checked
- a conversion kept the model but changed the structure

## Visibility

The eye control in the tree shows or hides a selected part. This is useful when one object blocks another, or when you want to check whether a small part exists without deleting anything.

If hiding one node makes more of the model disappear than expected, the file probably has nested groups. Select the parent and child nodes one at a time before assuming the wrong part was imported.

## Selected node details

Selecting a node shows the data Convert3D can read from that part.

![Selected node panel with material properties](/docs/viewing/selected-node-material.png)

For meshes, the panel can show the mesh name and the material assigned to that mesh.

![Selected mesh panel with material properties](/docs/viewing/selected-mesh-material.png)

Pay more attention to the `Type` and material values than the object name. Names like `Object_4` or `g_w_cg_taobao...` usually come from the exporter. They are ugly, but they are not proof that the model is broken.

## If the model looks empty

Fit the model to the view first.

If it still looks empty, open the scene tree and look for geometry below empty wrapper nodes. A file can have a visible root object with no geometry of its own. Very helpful, in the way 3D files sometimes are.

## If a part is missing

Check whether the part exists in the scene tree.

If it does not appear there, the source file may not have imported correctly, or the missing part may depend on an external file that was not included. This is common with formats that reference textures, material libraries, or linked assets outside the main file.

---

## View

**URL:** https://docs.convert3d.org/docs/viewing
**Description:** Inspect a 3D file in the browser

Use View when you need to inspect a 3D file before you convert, compress, or render it.

It is most useful when something already feels wrong: the model is empty, the scale is strange, materials are missing, or a file is much heavier than it looks.

## Open a model

Go to [convert3d.org/view](https://convert3d.org/view), then upload a supported 3D file.

For the fastest load time, use `glb` or `gltf`. Other supported formats may need to be prepared for browser viewing first.

## If the model looks empty

Fit the model to the screen before assuming the file failed.

![Selected 3D model part in the viewer](/docs/viewing/selected-object.png)

Some files place geometry far from the origin. Some arrive tiny. Some arrive huge. This is boring until it costs you an hour.

The axis gizmo helps you check whether the file is facing the expected direction.

![Axis gizmo with X, Y, and Z labels](/docs/viewing/axis-gizmo.png)

## What to check

Use View to answer these questions:

- Is the geometry actually in the file, or only a wrapper node?
- Are parts separate meshes, or one combined object?
- Did the file keep colors, transparency, and material values?
- Is the model dense enough to explain slow loading or upload failures?
- Is the orientation wrong before you send it to another app?

Material and Wireframe answer different questions. Use Material for surface data. Use Wireframe for geometry.

![View mode menu with Material and Wireframe options](/docs/viewing/material-wireframe-menu.png)

## Where to go next

Read [Scene hierarchy](/docs/viewing-scene-hierarchy) if you are trying to find one part of a model, hide or inspect a node, or understand why the object names look strange.

Read [Materials and wireframe](/docs/viewing-materials) if the model loads but the surface, texture, transparency, or mesh density looks wrong.

---

## Links

- [Feedback](https://convert3d.org/about)