ad-delayer

Files (3)

• SKILL.md
• api-endpoints.md · references/
• bria_delayer_client.sh · references/code-examples/

SKILL.md (first lines)

# Ad Delayer — Flat Ads Back Into Editable Layers

Take a finished ad — a JPEG or PNG with everything baked into one image — and get it back as editable layers. Bria's Ad Delayer reads the creative, separates it into background, imagery, logo, headline, body copy, and CTA, and returns each layer as its own asset plus a manifest describing where it sits, how big it is, and how its text is styled. Commercially safe, royalty-free, production-ready.

The everyday problem it solves: the ad shipped, the design file is gone, and someone needs a new size, a new price, or a translated headline.

## When to Use This Skill

Use this skill when the user wants to:
- **Turn a flat ad into layers** — "turn this ad into layers", "delayer this", "de-layer this creative", "image to layers"
- **Recover a lost design file** — "I lost the PSD", "we don't have the source file", "recover an editable version"
- **Make a finished ad editable** — "make this ad editable", "I need to change the headline on this banner", "swap the price in this creative"
- **Pull the pieces out of a creative** — "extract the layers", "get the logo and copy out of this ad separately", "split this banner into its elements"
- **Rebuild an ad for resizing or localisation** — "I need this ad in other sizes", "translate the copy on this ad", "rebuild it so we can restyle it"
- **Read an ad's structure** — "what elements is this ad made of?", "give me the text, fonts, and positions in this creative"
- **Batch a folder of finished ads** — "delayer all the ads in this folder"

### When NOT to Use This Skill

- **"Just remove the background" / "I need a cutout"** → use the **remove-background** skill. That is one transparent PNG of the foreground subject. This skill is the opposite job: it takes a whole ad apart into many layers, keeping text as text and reporting where each piece sits. If the ask is a single subject on transparency, it is not delayering.
- **Cutting one object out for compositing** → **remove-background** (whole subject) or **bria-ai** (`erase_from_image` for one object)
- **Generating or editing an image** — new visuals, restyling, inpainting, expanding → **bria-ai**
- **Resize, crop, watermark, format conversion** on a file you already have → **image-utils**
- **Building a fresh ad from scratch** (no source creative to take apart) → **bria-ai**

This skill does one thing: **take a finished ad image apart into editable layers**.

---

## Setup — Authentication

Before making any API call, you need a valid Bria access token.

### Step 1: Check for existing credentials

```bash
if [ -f ~/.bria/credentials ]; then
  BRIA_ACCESS_TOKEN=$(grep '^access_token=' "$HOME/.bria/credentials" | cut -d= -f2-)
  BRIA_API_KEY=$(grep '^api_token=' "$HOME/.bria/credentials" | cut -d= -f2-)
fi
if [ -z "$BRIA_ACCESS_TOKEN" ]; then
  echo "NO_CREDENTIALS"
elif [ -n "$BRIA_API_KEY" ]; then
  echo "READY"
else
  echo "CREDENTIALS_FOUND"
fi
```

If the output is `READY`, skip straight to making API calls — no introspection needed.
If the output is `CREDENTIALS_FOUND`, skip to Step 3.
If the output is `NO_CREDENTIALS`, proceed to Step 2.

### Step 2: Authenticate via device authorization

Start the device authorization flow:

**2a. Request a device code:**

```bash
DEVICE_RESPONSE=$(curl -s -X POST "https://engine.prod.bria-api.com/v2/auth/device/authorize" \
  -H "Content-Type: application/json")
echo "$DEVICE_RESPONSE"
```

Parse the response fields:
- `device_code` — used to poll for the token (keep this, don't show to user)
- `user_code` — the code the user must enter (e.g. `BRIA-XXXX`)
- `interval` — seconds between poll attempts

**2b. Show the user a single sign-in link.** Tell them exactly this — nothing more:

> **Connect your Bria account:** [Click here to sign in](https://platform.bria.ai/device/verify?user_code={user_code})
> Your code is **{user_code}** — it's already filled in.

Do NOT show two links. Do NOT show the raw URL separately. Do NOT use `verification_uri` from the API response. Keep it to one clickable link.

**2c. Poll for the token.** After showing the user the code, immediately start polling. Try up to 60 times with the given interval (default 5 seconds):

```bash
for i in $(seq 1 60); do
  TOKEN_RESPONSE=$(curl -s -X POST "https://engine.prod.bria-api.com/v2/auth/token" \
    -d "grant_type=urn:ietf:params:oauth:grant-type:device_code" \
    -d "device_code=$DEVICE_CODE")
  ACCESS_TOKEN=$(printf '%s' "$TOKEN_RESPONSE" | sed -n 's/.*"access_token" *: *"\([^"]*\)".*/\1/p')
  if [ -n "$ACCESS_TOKEN" ]; then
    BRIA_ACCESS_TOKEN="$ACCESS_TOKEN"
    REFRESH_TOKEN=$(printf '%s' "$TOKEN_RESPONSE" | sed -n 's/.*"refresh_token" *: *"\([^"]*\)".*/\1/p')
    mkdir -p ~/.bria
    printf 'access_token=%s\nrefresh_token=%s\n' "$BRIA_ACCESS_TOKEN" "$REFRESH_TOKEN" > "$HOME/.bria/credentials"
    echo "AUTHENTICATED"
    break
  fi
  sleep 5
done
```

If the output contains `AUTHENTICATED`, proceed to Step 3. Otherwise the code expired — start over from Step 2a.

**Do not proceed with any API call until authentication is confirmed.**

### Step 3: Verify billing status and resolve API key

Introspect the bearer token to check billing status and obtain the real API key for Bria API calls:

```bash
INTROSPECT=$(curl -s -X POST "https://engine.prod.bria-api.com/v2/auth/token/introspect" \
  -d "token=$BRIA_ACCESS_TOKEN")
BILLING_STATUS=$(printf '%s' "$INTROSPECT" | sed -n 's/.*"billing_status" *: *"\([^"]*\)".*/\1/p')
if [ "$BILLING_STATUS" = "blocked" ]; then
  BILLING_MSG=$(printf '%s' "$INTROSPECT" | sed -n 's/.*"billing_message" *: *"\([^"]*\)".*/\1/p')
  echo "BILLING_ERROR: $BILLING_MSG"
fi
ACTIVE=$(printf '%s' "$INTROSPECT" | sed -n 's/.*"active" *: *\([^,}]*\).*/\1/p' | tr -d ' ')
if [ "$ACTIVE" = "false" ]; then
  # Clear stale tokens so re-auth starts fresh (credentials file is re-created in Step 2c)
  printf '' > "$HOME/.bria/credentials"
  echo "TOKEN_EXPIRED"
fi

From Bria-AI/bria-skill, MIT.

More from Bria-AI/bria-skill