Import from TestRail

Plune reads your TestRail through its API and brings over its folders and cases. It is read-only: Plune sends TestRail only GET requests, so nothing in your TestRail is created, changed or deleted. The import is in Settings → Integrations, in the Import from other tools section, on the TestRail tab.

If you would rather use a file, or your TestRail cannot be reached from the internet, import a CSV or XLSX instead: Import and export.

Before you start

Who. Only an owner of the project can connect TestRail, import, replace the key or remove the connection. Other members see the page and are told to ask the owner.
TestRail 6.7 or newer. Plune reads TestRail in pages, which older versions do not support; the test then says so and suggests a file.
A public https address. Plune connects only to public https addresses. A TestRail behind a firewall, on a private network or at an address that redirects is refused; Plune does not follow redirects, so enter the address it redirects to.
A TestRail user and an API key. In TestRail, open My Settings → API Keys and create a key. Use a separate TestRail user who can only read the project you import: the key works with that user’s rights, so limiting the user is the real protection.

Connect

Open Settings → Integrations, Import from other tools, the TestRail tab, and press Connect TestRail.
Fill in TestRail address, E-mail (the TestRail user the key belongs to) and API key.
Press Test connection. Plune runs three checks: the address answers, TestRail accepts the e-mail and the key, this TestRail can be read in pages.
When all three pass, press Save connection. Save stays off until the test passes, and nothing is stored before that.

The API key is stored encrypted and never shown again: the page only says when it was saved. To change it use Replace credentials. Remove connection erases the saved key; cases that were already imported stay in Plune. Revoke the key in TestRail too, in My Settings → API Keys.

A failed test names the reason: TestRail rejected the e-mail or the key (it does not say which, so check both), the address could not be reached, the address is not allowed, the answer does not look like TestRail, TestRail is asking Plune to slow down, or TestRail is older than 6.7.

Preview, then import

Projects. Choose projects to import lists the projects of your TestRail with their suite and case counts, as TestRail reports them now. Pick one or more. They are imported into the Plune project you are in.
Preview (a dry run). Plune counts what would come over and writes nothing. It shows Folders (created as folders), Cases (create · update · skip), warnings, and an estimated time. Counting only reads from TestRail, at most 100 requests a minute, so a large project can take a few minutes.
Import. Press Import N cases. The import runs in the background — you can leave the page; progress stays in the queue and on the page, and you can Cancel import.

An import needs a dry run of the same TestRail project, made on this connection within the last 7 days; the server refuses it otherwise. If the preview says the cases would not fit, the project’s limit of cases is lower than what the import would add: choose fewer projects, or ask for a higher limit.

When it is done the page reports the folders and cases created, and the cases skipped with a reason: in the Bin in Plune (not recreated), marked deleted in TestRail, a BDD scenario, no room in the project, two Plune cases with the same key, or changed in both TestRail and Plune since the import (nothing was written).

What maps to what

In TestRail	In Plune
A project	A top-level folder with the project’s name
A suite (projects with several suites)	A folder under that one. With a single suite the sections go straight under the project folder
A section, nested by its parent	A nested folder
Case title	Case title. Labels become tags (`@label`; characters a tag cannot hold become `_`)
Precondition	Precondition
Steps (the Steps template)	Steps, each with its expected result; a step’s additional info is added to its text
Text steps (the Text template)	One step with the whole text, and the expected result of the case
Shared steps	Expanded into a copy of the steps in each case that uses them; the link to the shared set is not kept
Exploratory mission and goals	The case description (`Mission: …`, `Goals: …`); the case comes as a draft with one placeholder step
Priority	Low, High and Critical as they are, Medium becomes Normal; an unknown priority becomes the default and is counted
A case without an expected result	`Not specified in TestRail` is written, and the case is counted

Plune keeps up to 500 characters of a title, 200 steps of a case and 4,000 characters of a step; longer text is cut.

Repeat imports are safe

Every imported case gets the key testrail/C<id>: the TestRail case id with its C. A second import of the same project finds the case by this key and updates it instead of making a copy. Folders are matched too, so nothing is doubled.

A case that was changed in Plune after the import is never overwritten. If TestRail changed it as well, it is listed as a conflict and left as it is.
A case you moved to the Bin is not brought back.
If two cases in the project carry the same key, the import touches neither and says so.
An import that stopped (the network, a rejected key) continues from where it was without duplicating anything: press Continue, after replacing the key if TestRail rejected it.

Limits and rate limits

One import reads at most 200,000 records and makes at most 3,000 requests to TestRail. Past either, it stops with the reason on the page.
Plune stays under 100 requests a minute per connection. The quota of a TestRail Cloud is shared with everything else that calls it, your CI included.
When TestRail answers 429 (too many requests), the import pauses for the time TestRail asked and then goes on by itself from the same place. The page shows Paused · TestRail asked to slow down. A 429 does not fail the import.
If TestRail does not answer after several tries, the import stops with TestRail did not answer; nothing is lost, and Continue resumes it.

What is not imported

Users, roles, groups, permissions and sign-in settings. The author of an imported case is the person who imported it, and the creation time is the time of the import.
Reports, saved filters, project settings and announcements.
Attachments, and images embedded in the text: they stay dead links.
The case type. The preview counts it; the cases come over without it.
Custom fields you did not choose, and the kinds Plune cannot hold (see Estimates and custom fields).
BDD scenarios (Plune has no Gherkin steps) — skipped and counted.
Case history, milestones and plans as such, configurations, data sets, baseline suites.

Estimates and custom fields

Estimates. A case’s TestRail estimate (30s, 1hr 30min, 2min 15sec, the parts in any order) becomes the case’s estimate in whole seconds. It is written into a new case, and into a case already in Plune only if that case has no estimate yet: an estimate set in Plune is never overwritten. A text that is not a time is not carried over and is counted in cases_estimate_not_transferred. TestRail’s forecast is not carried over.

References. A case’s refs come over as they are into a text field named TestRail refs (up to 1,000 characters).

Custom fields come over only when you choose them. The app has no screen for the choice yet; on the API it works like this:

The answer of a dry run (GET …/imports/{jobId} of a dry run) lists the project’s case fields in fields: the name, the TestRail type, whether Plune can hold it (supported, with a reason when it cannot), how many cases hold a value, and a dropdown’s options.
POST …/imports takes customFields: for each field to carry, its systemName from that list and an action — create makes a Plune custom field of the same name (an existing one of the same name and kind is used, not doubled), map writes into the live case field you name in pluneFieldId. At most 50 fields an import.

TestRail type	Plune custom field
Text, String, URL	Text
Date	Text, as `YYYY-MM-DD`
Integer	Number
Dropdown	List with the same options (None is no value)
Checkbox	List Yes / No; a ticked box is Yes, an unticked one is no value
Multi-select, User, Milestone, Steps, Scenario	Not supported: listed with the reason, not carried over

A field the import creates or maps is marked as coming from TestRail (source: "testrail" in the custom fields API). A value the Plune field cannot hold (an option it does not have, a date written as 05/11/2026) is not written and is counted in cases_custom_values_skipped. A value already set in Plune is not overwritten, so a repeat import changes nothing.

History and sync

Two more things have a screen in Settings → Integrations → TestRail (Import runs and results in the project picker, Sync modes and Sync changes from TestRail… on the connection) and are also on the API. The API routes need a signed-in session (a cookie); an API token is not accepted on them. All are under /v1/projects/{id}/integrations/testrail, and every write needs the owner. The routes and their answers are in the API reference.

History: runs and results. POST …/dry-run and POST …/imports take an optional history: { "mode": "none" | "months" | "all", "months": 12 } (months goes only with the mode months; 1 to 120, 12 if left out). Without it only the cases are imported. Imported runs keep the dates TestRail has; a closed run is finished, an open run stays open and is filled in by a repeat import. Each result is kept once, so a repeat import adds no duplicates. Free keeps 30 days of runs: older ones are counted in the dry run’s runs_beyond_plan and are not imported. TestRail’s Retest and its own statuses come in as skipped with a sub-status of that name (ten own sub-statuses a status at most). Authors, attachments of results and plans as entities are not carried over.

Sync from TestRail. GET …/sync, PUT …/sync/modes, POST …/sync/dry-run, POST …/sync. A mode is set per entity (cases, suites, fields), off by default, and a sync is refused for an entity that is off. A sync is pull only: it takes which, all (updates what was imported) or new (adds only what is missing), and needs one finished import of the TestRail project. A case changed in Plune is never overwritten. Cases that have disappeared from TestRail are listed, not deleted; with all, an active one is moved to detached.

Checked on TestRail Cloud

On 24 October 2026 the bridge was run against a TestRail Cloud instance from start to end: connecting, the preview, the import of cases, a repeat import that changed nothing, a sync and removing the connection; the import with all of a project’s history (2,000 cases, 10 runs, 20,000 results, about two minutes); and estimates and dropdown fields chosen through the API. Text, number, date and checkbox fields were not on that instance and were checked against a simulated TestRail only.

Imported runs and results count like the ones your CI sends: the same plan limits apply to them (Free keeps 30 days of runs, see History and sync).

Not documented, needs the product owner

A walk-through with screenshots of a live TestRail.
The state a case gets when it is imported.

The parallel period with TestRail and the first steps after the import are in Move from TestRail in a day.