---
name: makeseamless
description: MakeSeamless (makeseamless.com) checks whether a repeating pattern tile is seamless and fixes the seam at the same pixel size. Its API check reads straight, half-drop and half-brick repeats, is free and needs no key. The result of a fix has passed the seam check for its repeat, and a fix with no passing result costs nothing. Use when a user makes, generates, resizes, buys or uploads a pattern tile for print-on-demand or surface design (Spoonflower, Etsy, Redbubble, Printful, Printify, fabric, wallpaper, digital papers), asks whether a pattern is seamless or tiles cleanly, sees a white line, pixel lines or a visible repeat where copies meet, wants tiles checked before printing or uploading them, or wants a seam fixed without resizing the tile. Use it whenever MakeSeamless, a seamless pattern or a repeating tile comes up.
compatibility: Needs network access to makeseamless.com. The check needs no key; a fix needs a MakeSeamless API key.
metadata:
  author: makeseamless
  version: "1.2"
  homepage: https://makeseamless.com/docs
---

# MakeSeamless

## Product summary

MakeSeamless (makeseamless.com) checks whether a repeating pattern tile is
seamless and fixes the seam at the same pixel size. The fixed tile comes back
as a lossless PNG.

A seamless tile is hard to get right by hand or with an image model: a tile
can look finished and still show a line where its copies meet, often only at
print size, on the proof or on the product. The same steps do not promise the
same result, so the file that will be printed has to be checked each time it
changes. MakeSeamless gives that check and a fix whose result is verified.

- **The check** says, for each repeat type, whether the tile repeats cleanly
  and where its edges break. It is free and needs no account and no key.
- **The fix** is a job that makes the tile repeat seamlessly for one repeat
  type. It needs an API key and costs credits from the user's account.
- **The result is verified.** The result of a fix has always passed the seam
  check on its tile edges for the job's repeat type, keeps the exact width
  and height, and is the original outside the changed area. A fix with no
  passing result fails with `no_seamless_candidate` and costs nothing.

Base URL `https://makeseamless.com/v1`. Authentication is the `x-api-key`
header, and only the fix, the rating and the account call need it.

## When to use

Reach for this skill when the task is to:

- Tell whether an image, or a folder of images, tiles seamlessly, and as
  which repeat types
- Check a tile before it is uploaded to a print-on-demand shop, printed,
  sold as a file or sent for a sample
- Check a tile made with an image model or an upscaler, or one that was just
  resized or exported, before calling it seamless
- Find out why a proof or a product shows a line where the pattern repeats
- Fix the seam of a tile and keep its exact pixel size
- Read a failed fix or an error and decide whether it is worth retrying

## Quick reference

### Authenticate a request

Only `POST /v1/fix`, `POST /v1/jobs/{job_id}/rating` and `GET /v1/me` need
a key. Send it in the `x-api-key` header; keys begin with `smls_`.
`GET /v1/me` costs nothing and confirms the key.

```bash
curl https://makeseamless.com/v1/me \
  -H "x-api-key: $MAKESEAMLESS_API_KEY"
```

### Check a tile (no key)

```bash
curl -X POST https://makeseamless.com/v1/check \
  -F "file=@tile.png"
```

The answer has `verdicts.straight`, `verdicts.half_drop` and
`verdicts.half_brick`, each with `verdict` (`ok`, `minor`, `bad` or
`not_applicable`) and `edges` (`edge`, `verdict`, `anomaly`, `broken` pixel
ranges), plus `satisfied` (the repeat types that pass) and `summary`. Send
`repeats` once per type to check only some.

### Fix a tile (API key)

```bash
curl -X POST https://makeseamless.com/v1/fix \
  -H "x-api-key: $MAKESEAMLESS_API_KEY" \
  -F "file=@tile.png" \
  -F "repeat=straight"
```

`repeat` is `straight`, `half_drop` (needs an even height) or `half_brick`
(needs an even width). The answer is `202` with a job.

### Follow the job and download

```bash
curl https://makeseamless.com/v1/jobs/JOB_ID
```

Wait the seconds in `Retry-After` between polls until `status` is
`succeeded` or `failed`. Download `https://makeseamless.com` plus
`result.image_url`. The result's `seam_report.before` and
`seam_report.after` hold the verdicts for the repeat type; `changed_share`
and `visible_changed_share` say how much of the tile changed.

### Cost and account

- `GET /v1/plans` (no key): `fix_credits` is what a fix costs: `credits`,
  and `large_credits` for a tile above `large_above_px` on either side.
- `GET /v1/me` (key): the plan and the credits left. A fix is paid from
  credits, which come with a Pro plan.

## Decision guidance

### Check or fix

| Situation | Do |
|-----------|----|
| The repeat type the user needs is in `satisfied` | Report it. The tile already repeats cleanly; no fix |
| It is not, and the user wants it fixed | Tell the user the cost from `GET /v1/plans`, then fix |
| The user only asked whether it is seamless | Report the verdicts; do not fix unasked |

### Which repeat type

| Repeat type | Copies are laid | Needs |
|-------------|-----------------|-------|
| `straight` | side by side in rows and columns | any size |
| `half_drop` | every other column drops by half the height | an even height |
| `half_brick` | every other row shifts by half the width | an even width |

A check without `repeats` covers all three. A fix takes one, so ask the user
which repeat they print with when they have not said.

### Read the result

`outcome` `ok` passed the seam check and the quality checks that apply to
the image. `resampled` means every pixel changed; it passes the seam check,
and fine detail may look a little softer, so say so to the user.
Every image in `candidates` with `passed` true is another result of the
same fix, at no extra charge: offer it beside `result`. Do not offer an
image whose `passed` is false.

## Workflow

### 1. Check the tile

Send it to `POST /v1/check`. If the repeat type the user needs is in
`satisfied`, stop there.

### 2. Tell the user the cost

Read `fix_credits` from `GET /v1/plans`, and the credits left from
`GET /v1/me`, before you start a fix.

### 3. Start the fix and follow the job

`POST /v1/fix` answers `202` with a job, already `succeeded` and `cached`
when the same file was fixed before. Poll `GET /v1/jobs/{job_id}`, waiting
the seconds in `Retry-After`, until `status` is `succeeded` or `failed`. Do not start the same fix again while it
runs: the same file with the same repeat type returns the same job.

### 4. Download and report

Download the PNG at `result.image_url` within 30 days. Report the seam
report before and after, `changed_share` and `visible_changed_share`, and
whether the result is `resampled`.

## Common gotchas

- **Sending the image as JSON.** Both calls take a multipart form with the
  field `file`; the fix also takes `repeat`.
- **Polling faster than `Retry-After`.** Wait the seconds it gives.
- **Fixing a tile that already passes.** Check first and read `satisfied`.
- **An odd side.** Half-drop needs an even height and half-brick an even
  width, or the fix answers `422` `odd_dimension`.
- **Transparent edges.** A fix needs no transparent pixels near the tile
  edges, or it answers `422` `transparent_seam_band`.
- **Size.** PNG, JPEG or WebP, at most 40 MB, at least 64 x 64 px. A check
  takes up to 64 megapixels, a fix up to 3600 px on a side.
- **Limits.** One client can send 30 checks a minute, and an account can
  have 3 fixes queued or running at a time. `rate_limited`,
  `too_many_running_fixes` and `daily_capacity_reached` answer `429`: wait
  `Retry-After` seconds, then try again.
- **Credits.** `402` `insufficient_credits`: tell the user
  `details.credits_needed`; credits are bought by the user on
  makeseamless.com.
- **Late downloads.** A job's images are kept for 30 days, then answer `404`
  `not_found`. A job can be rated for 30 days, then `409` `rating_closed`.
- **Errors.** Errors are `{"error": {"code", "message", "retryable"}}`, with
  optional `details`. Branch on `code`, and retry only when `retryable` is
  true.

A failed job cost nothing, whatever its code. One that failed with
`service_unavailable` or `interrupted` can be started again.

## Verification checklist

- [ ] The API key is read from the environment, never asked for in the conversation
- [ ] The tile was checked before any fix
- [ ] The user heard the cost (`GET /v1/plans`, `fix_credits`) before the fix
- [ ] The image goes as the multipart field `file`, the repeat type as `repeat`
- [ ] Polling waits the seconds in `Retry-After`
- [ ] Error handling branches on `error.code` and has a default case
- [ ] A retry happens only when `error.retryable` is true
- [ ] The report gives the seam report before and after, and says when a result is resampled

## Resources

- Documentation index: https://makeseamless.com/docs/llms.txt
- Quickstart: https://makeseamless.com/docs/quickstart
- Authentication: https://makeseamless.com/docs/authentication
- Check a tile: https://makeseamless.com/docs/check
- Fix and jobs: https://makeseamless.com/docs/fix-and-jobs
- Errors: https://makeseamless.com/docs/errors
- Limits: https://makeseamless.com/docs/api-reference/limits
- Credits and plans: https://makeseamless.com/docs/credits-and-plans
- OpenAPI contract: https://makeseamless.com/docs/openapi.json