TestingOps.ai

Design tools · Native connection

Zeplin and TestingOps: test cases from the design handoff

Zeplin holds the screens developers build from, with the annotations and notes that explain them. TestingOps reads that handoff so its AI test agents write cases from the same material.

  • Native connection
  • Available
Request a demo Getting started with the Zeplin API
Connection
Native connection
Writes back
Nothing, it only reads
Last checked
7 Nov 2026

In short

Zeplin and TestingOps in short

The Zeplin connection reads handoff projects through the Zeplin API with a personal access token.

Each screen becomes a knowledge-base document with its texts in reading order, controls, components, prototype links, annotations and designer notes, and each flow board becomes a document of its own.

Agents use these documents when they write and review test cases; Zeplin is only read, and no runnable tests or visual comparisons come out of it.

The token's account must be a Member of the project, because Zeplin does not let Reviewers read screen layers.

What it does

What it does for your testing

  1. 1

    Annotations become expected results

    Input
    Annotations on a screen, such as requirement and behavior notes
    TestingOps
    Lists each annotation with its type next to the screen's texts and controls
    Output
    Described behaviour that agents can turn into checks in expected results
  2. 2

    Designer notes keep the decisions

    Input
    Note threads on a screen
    TestingOps
    Keeps the first comment with up to three replies and marks resolved notes
    Output
    Decisions from the handoff discussion, available when cases are written
  3. 3

    Flow boards become journeys

    Input
    Zeplin flow boards with screens and connectors
    TestingOps
    Writes one document per board with its screens and the transitions between them
    Output
    Multi-screen paths for end-to-end scenarios
  4. 4

    Only changed screens are read

    Input
    A project with many screens
    TestingOps
    Compares each screen's update time and its note and annotation counts with the last sync
    Output
    Follow-up syncs read only what changed and stay within Zeplin's request limit

Step by step

How it works

  1. Save a personal access tokenCreate a token in Zeplin under Profile → Developer and save it under Integrations → Project tools → Design tools → Zeplin.
  2. Link a project or a screenIn the project's Knowledge Base, add a Design tools source: pick a Zeplin project or paste project or screen links; zpl.io short links work too. A screen link brings only that screen; a project link brings every screen and flow board, up to 200 screens.
  3. TestingOps reads what changedIt reads screen details only for screens that changed since the last sync, up to 120 per sync, and spaces its requests to stay under Zeplin's 200 requests a minute. The rest follows on the next sync.
  4. Screens and flow boards become documentsEach document gives the screen's section, texts, controls, components, prototype links, annotations and designer notes, with a link back to Zeplin.
  5. Agents write cases from the handoffAgents search these documents while writing and reviewing test cases; the cases then run on your execution provider.

If the account is a Reviewer on the project, Zeplin refuses screen layers. TestingOps then syncs screen names, annotations and notes only, and shows a warning.

Connect

Setup

  1. In Zeplin, open Profile → Developer and create a personal access token with an account that is a Member of the projects you want to read.
  2. In TestingOps, open Integrations → Project tools → Design tools → Zeplin and save the token.
  3. Open Knowledge Base, pick the project, select Add source on Design tools, choose the Zeplin connection, pick a project or paste project or screen links, then select Link to RAG.
  4. Select Sync now. Large projects continue on later syncs, which run automatically.

Documentation: Getting started with the Zeplin API

Where you connect it in TestingOps: Integrations → Project tools → Design tools → Zeplin

Use cases

Use cases

Write cases from handoff annotations

Trigger
A feature's screens are handed off in Zeplin with requirement and behavior annotations
Uses
Annotations, screen texts and components
Agent activity
Turns each behavior annotation into expected results and uses the screen texts as the exact messages to check
Result
Draft test cases that follow the handoff
Condition
The connected account must be a Member of the project

Follow design revisions during development

Trigger
Designers publish new versions of screens
Uses
Only the changed screens, re-read on the next sync
Agent activity
Works from the updated documents when it writes or reviews cases for those screens
Result
The knowledge base follows the latest handoff
Condition
Up to 120 changed screens are read per sync; the rest arrive on later syncs

Plan journeys from flow boards

Trigger
The designer maintains a flow board for onboarding
Uses
The board's screens and connectors
Agent activity
Plans a scenario for each path across the screens
Result
End-to-end scenarios that match the designed flow
Condition
Up to 20 flow boards per project are read

Capabilities

Capabilities and limits

What is read

  • Screens of a project, or a single screen: texts in reading order, controls from component names, components, prototype links, annotations, designer notes, variant, description, tags and section
  • Flow boards, up to 20 per project: the screens on each board and the connectors between them
  • Project and screen links, including zpl.io short links; your active projects for the picker

What is produced

One knowledge-base document per screen and per flow board, with a link back to Zeplin

Where it can write

Nothing in Zeplin.

How it connects

Zeplin API with your personal access token, sent as a Bearer token; requests are spaced to stay under Zeplin's limit of 200 a minute

Account and permissions

  • A Zeplin personal access token (Zeplin → Profile → Developer)
  • An account that is a Member of the project: Reviewers cannot read screen layers
  • On testingops.ai, use a personal access token: the Connect with Zeplin sign-in is not offered there

Limits

  • Up to 200 screens per project link, and up to 120 changed screens read in detail per sync
  • Archived projects cannot be read
  • With a Reviewer account, only screen names, annotations and notes are synced
  • Each Zeplin connection counts toward your package's integration limit
  • No runnable tests or visual comparisons are generated from screens

Example

Example: how a team uses it

Illustrative scenario, not a customer story.

A banking app team hands off its card-freeze feature in Zeplin. The Freeze card screen carries a behavior annotation saying the toggle asks for confirmation, and a designer note agreeing that frozen cards still show recent transactions.

From those documents an agent drafts cases for freezing a card, cancelling the confirmation and checking the transaction list of a frozen card, each with the on-screen texts as expected results.

Frequently asked questions

Where do I create the Zeplin token?

In Zeplin under Profile → Developer → Personal access tokens. On testingops.ai the Connect with Zeplin sign-in is not offered, so the personal access token is the way to connect.

Why were only screen names and notes synced?

The account behind the token is a Reviewer on the project, and Zeplin does not let Reviewers read screen layers. Ask a project admin to make it a Member, then sync again.

Will a project with hundreds of screens be read?

A project link covers up to 200 screens. Each sync reads up to 120 changed screens in detail, so a large first sync completes over several syncs; after that, only changed screens are read.

Are annotations and designer notes included?

Yes. Annotations appear with their type, and designer notes with up to three replies, marked when they are resolved.

Can I link a single screen?

Yes. A screen link brings only that screen; a project link brings every screen and the project's flow boards.

Does TestingOps write to Zeplin?

No. It only reads projects, screens, notes, annotations and flow boards.

Next step

Bring a Zeplin project that is about to be built to a demo and see the cases agents draft from its annotations and notes.

Request a demoMore design tools integrations