> ## Documentation Index
> Fetch the complete documentation index at: https://apixo.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Image Watermark Remover

> Single-image watermark removal API for image-to-image cleanup workflows

## Overview

Image Watermark Remover removes visible text or logo watermarks from one input image and returns a cleaned image URL. Use this page when you are ready to call the API after trying the model in the APIXO playground.

| Capability            | Value                             |
| --------------------- | --------------------------------- |
| Model ID              | `image-watermark-remover`         |
| Mode                  | `image-to-image`                  |
| Input images          | Exactly 1 public image URL        |
| Output formats        | `jpg`, `jpeg`, `png`, `webp`      |
| Default output format | `jpg`                             |
| Result delivery       | Async polling or webhook callback |

<Tip>
  This model is fixed to a single-image image-to-image workflow. It does not accept prompts, masks, seeds, resolution controls, or multiple reference images.
</Tip>

## Endpoint and authentication

Base URL:

```text theme={null}
https://api.apixo.ai/api/v1
```

| Method | Endpoint                                              | Purpose                               |
| ------ | ----------------------------------------------------- | ------------------------------------- |
| `POST` | `/generateTask/image-watermark-remover`               | Submit a watermark removal task       |
| `GET`  | `/statusTask/image-watermark-remover?taskId={taskId}` | Poll task status and retrieve results |

All requests require your APIXO API key:

```http theme={null}
Authorization: Bearer YOUR_API_KEY
```

Submit requests also require:

```http theme={null}
Content-Type: application/json
```

## Copy-paste async quickstart

This minimal request submits one image cleanup task and returns a `taskId`.

```bash theme={null}
curl -X POST "https://api.apixo.ai/api/v1/generateTask/image-watermark-remover" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "request_type": "async",
    "input": {
      "image_urls": [
        "https://example.com/photo-with-watermark.jpg"
      ],
      "output_format": "jpg"
    }
  }'
```

Successful response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678"
  }
}
```

Save the `taskId`; you need it to poll for the final result.

## Poll for result

```bash theme={null}
curl -X GET "https://api.apixo.ai/api/v1/statusTask/image-watermark-remover?taskId=task_12345678" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

Processing response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "processing",
    "createTime": 1767965610929
  }
}
```

Success response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "success",
    "resultJson": "{\"resultUrls\":[\"https://file.apixo.ai/watermark-free-image.jpg\"]}",
    "createTime": 1767965610929,
    "completeTime": 1767965652317,
    "costTime": 41388
  }
}
```

Failed response:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "failed",
    "failCode": "UPSTREAM_ERROR",
    "failMsg": "Upstream error",
    "createTime": 1767965610929,
    "completeTime": 1767965620132
  }
}
```

Parse `resultJson` after `state` becomes `success`:

```javascript theme={null}
const payload = JSON.parse(data.resultJson);
const imageUrls = payload.resultUrls;
```

## Request body

### Default JPG output

```json theme={null}
{
  "request_type": "async",
  "input": {
    "image_urls": [
      "https://example.com/photo-with-watermark.jpg"
    ],
    "output_format": "jpg"
  }
}
```

### PNG output

```json theme={null}
{
  "request_type": "async",
  "input": {
    "image_urls": [
      "https://example.com/marketing-banner.png"
    ],
    "output_format": "png"
  }
}
```

### Explicit mode

`mode` is optional because this endpoint has only one workflow. If you include it, it must be `image-to-image`.

```json theme={null}
{
  "request_type": "async",
  "input": {
    "mode": "image-to-image",
    "image_urls": [
      "https://example.com/photo-with-watermark.webp"
    ],
    "output_format": "webp"
  }
}
```

## Parameters

<ParamField body="request_type" type="string" required default="async">
  Result delivery mode. Use `async` for polling with `statusTask`, or `callback` for webhook delivery.
</ParamField>

<ParamField body="callback_url" type="string">
  Required when `request_type` is `callback`. Must be a public HTTPS URL that can receive the final task payload. See [Webhooks](/api-reference/webhooks).
</ParamField>

<ParamField body="input" type="object" required>
  Image Watermark Remover input parameters.

  <Expandable title="properties">
    <ParamField body="mode" type="string" default="image-to-image">
      Fixed workflow mode. If provided, the only supported value is `image-to-image`.
    </ParamField>

    <ParamField body="image_urls" type="string[]" required>
      Source image URLs. Must contain exactly 1 non-empty string. Use a public, directly fetchable image URL.
    </ParamField>

    <ParamField body="output_format" type="string" default="jpg">
      Output image format. Supported values: `jpg`, `jpeg`, `png`, `webp`. `jpeg` is accepted as an alias for `jpg`.
    </ParamField>
  </Expandable>
</ParamField>

## Response format

### Submit task response

`POST /generateTask/image-watermark-remover` returns a task ID when the task is accepted:

<ResponseField name="code" type="integer">
  API status code. `200` means the task was accepted.
</ResponseField>

<ResponseField name="message" type="string">
  Human-readable status message.
</ResponseField>

<ResponseField name="data.taskId" type="string">
  Unique task identifier used with the status endpoint.
</ResponseField>

### Status response fields

<ResponseField name="taskId" type="string">
  Unique task identifier.
</ResponseField>

<ResponseField name="state" type="string">
  Current task state: `pending`, `processing`, `success`, or `failed`.
</ResponseField>

<ResponseField name="resultJson" type="string">
  JSON string containing the cleaned image URLs. Present when `state` is `success`.
</ResponseField>

<ResponseField name="failCode" type="string">
  Machine-readable failure code. Present when `state` is `failed`.
</ResponseField>

<ResponseField name="failMsg" type="string">
  Human-readable failure message. Present when `state` is `failed`.
</ResponseField>

<ResponseField name="createTime" type="integer">
  Task creation timestamp in Unix milliseconds.
</ResponseField>

<ResponseField name="completeTime" type="integer">
  Task completion timestamp in Unix milliseconds. Present after completion when available.
</ResponseField>

<ResponseField name="costTime" type="integer">
  Processing duration in milliseconds when available.
</ResponseField>

### `resultJson` payload

`resultJson` is a JSON-encoded string. After parsing it, the payload has this shape:

```json theme={null}
{
  "resultUrls": [
    "https://file.apixo.ai/watermark-free-image.jpg"
  ]
}
```

## Webhook callback mode

Use callback mode when your backend should receive the final result automatically instead of polling.

```bash theme={null}
curl -X POST "https://api.apixo.ai/api/v1/generateTask/image-watermark-remover" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "request_type": "callback",
    "callback_url": "https://your-server.com/webhooks/apixo",
    "input": {
      "image_urls": [
        "https://example.com/photo-with-watermark.jpg"
      ],
      "output_format": "png"
    }
  }'
```

The final callback payload uses the same task response shape as status polling:

```json theme={null}
{
  "code": 200,
  "message": "success",
  "data": {
    "taskId": "task_12345678",
    "state": "success",
    "resultJson": "{\"resultUrls\":[\"https://file.apixo.ai/watermark-free-image.png\"]}",
    "createTime": 1767965610929,
    "completeTime": 1767965652317,
    "costTime": 41388
  }
}
```

See [Webhooks](/api-reference/webhooks) for delivery requirements and retry behavior.

## Billing

Image Watermark Remover is billed per submitted image task. Because `image_urls` must contain exactly one image, each accepted task counts as one image for billing.

| Unit        | APIXO price      | What changes price                                                        |
| ----------- | ---------------- | ------------------------------------------------------------------------- |
| `PER_IMAGE` | `$0.015 / image` | Fixed unit price; `output_format` does not create a separate pricing tier |

For the current public price, see [Pricing](https://apixo.ai/pricing).

## Latency and polling

This endpoint is asynchronous. Actual latency can vary by image complexity, upstream queue load, and result storage time.

| Stage            | Recommendation                                 |
| ---------------- | ---------------------------------------------- |
| First poll       | 10s-20s after task creation                    |
| Poll interval    | 5s-10s                                         |
| High concurrency | Prefer callback mode to reduce polling traffic |

## Errors and troubleshooting

### HTTP errors

| Code  | Meaning                                                                                    | What to do                                       |
| ----- | ------------------------------------------------------------------------------------------ | ------------------------------------------------ |
| `400` | Invalid request body, unsupported mode, invalid output format, or wrong `image_urls` shape | Fix the request before retrying                  |
| `401` | Missing or invalid API key                                                                 | Check the `Authorization` header                 |
| `402` | Insufficient balance or quota                                                              | Add balance or switch account/key                |
| `403` | Key or route cannot access the model                                                       | Check permissions and route strategy             |
| `429` | Rate limit or concurrency limit reached                                                    | Retry with exponential backoff                   |
| `500` | Server error                                                                               | Retry with backoff                               |
| `502` | Upstream service error                                                                     | Retry with backoff                               |
| `504` | Upstream timeout                                                                           | Retry or use callback mode for long-running jobs |

### Validation errors

| Error                                                                    | Cause                                            | Fix                                       |
| ------------------------------------------------------------------------ | ------------------------------------------------ | ----------------------------------------- |
| `The required parameter {{input}} is missing.`                           | Missing top-level `input` object                 | Send an `input` object                    |
| `The required parameter {{image_urls}} is missing.`                      | Missing `input.image_urls`                       | Send `image_urls` with exactly one URL    |
| `The parameter {{image_urls}} must be Array type.`                       | `image_urls` is not an array                     | Use a JSON array                          |
| `The parameter {{image_urls}} must contain exactly 1 image.`             | `image_urls` is empty or contains multiple items | Send exactly one image URL                |
| `The parameter {{image_urls}} Array elements must be String type.`       | The image URL item is not a string               | Use a string URL                          |
| `The parameter {{image_urls}} cannot contain empty string.`              | The image URL is blank after trimming            | Use a non-empty public image URL          |
| `Invalid mode type. Supported: image-to-image`                           | `mode` is not `image-to-image`                   | Omit `mode` or set it to `image-to-image` |
| `The parameter {{output_format}} must be String type.`                   | `output_format` is not a string                  | Use a string value                        |
| `The parameter {{output_format}} must be either 'jpg', 'png' or 'webp'.` | Unsupported output format                        | Use `jpg`, `jpeg`, `png`, or `webp`       |

### Task failure codes

| Fail code              | Meaning                                               | What to do                                      |
| ---------------------- | ----------------------------------------------------- | ----------------------------------------------- |
| `INVALID_PARAMETER`    | A parameter is unsupported or malformed               | Check `mode`, `image_urls`, and `output_format` |
| `INSUFFICIENT_BALANCE` | The account does not have enough balance for the task | Add balance before retrying                     |
| `UPSTREAM_ERROR`       | Upstream-side failure                                 | Retry with backoff                              |
| `TIMEOUT`              | Generation did not finish in time                     | Retry or use callback mode                      |

See [Error Codes](/api-reference/errors) for the full error reference.

## Related links

* [Generation API Overview](/models)
* [Generate Task](/api-reference/generate-task)
* [Status Task](/api-reference/status-task)
* [Webhooks](/api-reference/webhooks)
* [Error Codes](/api-reference/errors)
* [Parameter Specification](/api-reference/parameters)
* [Routing Strategies](/concepts/routing-strategies)
* [Pricing](https://apixo.ai/pricing)
