Getting Started with TestProject: Free Selenium and Appium Testing
TestProject was shut down in 2023, but its setup patterns remain instructive — they defined the agent-based test automation model that several current tools follow. If you're evaluating tools that use similar architectures (agent installation, cloud dashboard, Selenium/Appium wrapping), this guide explains what the setup looked like and what problems each step solved.
For teams currently looking to set up free Selenium or Appium testing today, we'll also cover what the equivalent setup looks like with tools that are still active.
The TestProject Setup Model
TestProject's onboarding had four sequential steps:
- Create a free account at app.testproject.io
- Download and install the TestProject Agent on your machine
- Create a project and test in the dashboard
- Either use the no-code recorder or install the OpenSDK for code-based tests
Each step had specific requirements and common failure points.
Step 1: Account and Project Creation
After account creation, TestProject required you to create a Project before anything else. Projects were the top-level container for tests, jobs (test suites), and reports.
Project settings that mattered:
- Project name: Appears in all reports — use something meaningful (
checkout-flownotproject-1) - Agent assignment: Projects could be locked to specific agents, useful for mobile tests requiring a physical device
Step 2: Agent Installation
The agent was a Java 11+ application packaged as:
- Windows:
.exeinstaller - macOS:
.dmg - Linux:
.tar.gz(manual install) or Docker image
Linux Manual Installation
# Download the agent binary
wget https://github.com/testproject-io/agent/releases/latest/download/testproject-agent.tar.gz
# Extract
tar -xzf testproject-agent.tar.gz -C /opt/testproject-agent
# Create systemd service
sudo tee /etc/systemd/system/testproject-agent.service > /dev/null <<EOF
[Unit]
Description=TestProject Agent
After=network.target
[Service]
Type=simple
User=testrunner
WorkingDirectory=/opt/testproject-agent
ExecStart=/opt/testproject-agent/testproject-agent
Restart=on-failure
RestartSec=10
Environment="TP_API_KEY=your-api-key-here"
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl enable testproject-agent
sudo systemctl start testproject-agentDocker Installation
docker run -d \
--name testproject-agent \
-e TP_API_KEY=your-api-key \
-e TP_AGENT_ALIAS=my-agent \
-p 8585:8585 \
-p 8686:8686 \
-v /var/run/docker.sock:/var/run/docker.sock \
testproject/agent:latestThe -v /var/run/docker.sock:/var/run/docker.sock mount let the agent spawn browser containers on demand — the agent didn't include browsers itself, it orchestrated them via Docker.
Agent Registration
After starting, the agent registered with TestProject's cloud automatically using the API key. You could verify registration from the dashboard under Agents — a green indicator meant the agent was connected and ready.
Common registration failures:
- Firewall blocking outbound HTTPS to
*.testproject.ioon port 443 - API key mismatch (key from wrong account or project)
- Java version below 11 (the agent required Java 11+)
- Port 8585 already in use by another process
Step 3: First Web Test with the Recorder
The TestProject recorder was a Chrome extension. After installation:
- Open Chrome, navigate to your test URL
- Click the TestProject extension icon
- Click Record — the recorder toolbar appeared
- Interact with the page (click, type, navigate)
- Click Stop Recording when done
- The test appeared in your project dashboard
Each recorded interaction became a step. Steps were displayed in a table with:
- Action type (Click, Type, Verify, Navigate)
- Element locator (ID, CSS, XPath — whichever the recorder captured)
- Value (for Type actions)
- Pass/fail assertion (if you recorded a verification step)
Adding Assertions to Recorded Tests
Recording interaction steps without assertions created tests that could never fail — they'd pass even if the page showed an error. The correct pattern was to record a verification after each significant interaction:
- Fill in login form → click Submit
- Add step: Verify element present (
#dashboard-header) → this is the assertion - Add step: Verify text equals (
Welcome, Test User) → confirms correct user loaded
In the recorder, verification steps were added via the + Add Step button after completing an interaction sequence.
Step 4: Python SDK Setup for Code-Based Tests
For tests requiring conditional logic, loops, or external data — things the no-code recorder couldn't express — the OpenSDK was the solution.
Installation
pip install testproject-python-sdkSDK Prerequisites
The OpenSDK required:
- Python 3.6+
- The TestProject agent running locally (or at a reachable address)
- Your TestProject API token (different from the API key — found under account settings)
First SDK Test
import pytest
from src.testproject.sdk.drivers import webdriver
from selenium.webdriver.common.by import By
TESTPROJECT_TOKEN = "your-token-here" # Or set TP_DEV_TOKEN env var
def test_user_login():
"""Verify successful login redirects to dashboard."""
driver = webdriver.Chrome(token=TESTPROJECT_TOKEN)
try:
# Navigate to login page
driver.get("https://example.com/login")
# Fill login form
email_field = driver.find_element(By.ID, "email")
email_field.clear()
email_field.send_keys("testuser@example.com")
password_field = driver.find_element(By.ID, "password")
password_field.clear()
password_field.send_keys("testpassword123")
# Submit
driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()
# Assert redirect to dashboard
assert "/dashboard" in driver.current_url, \
f"Expected /dashboard in URL, got: {driver.current_url}"
# Assert user name displayed
user_name = driver.find_element(By.CSS_SELECTOR, ".user-greeting").text
assert "Test User" in user_name, \
f"Expected 'Test User' in greeting, got: {user_name}"
finally:
driver.quit()Run with pytest:
python -m pytest test_login.py -vEach test run appeared in the TestProject dashboard automatically, with step-by-step screenshots and pass/fail status.
Setting the Token via Environment Variable
export TP_DEV_TOKEN=your-token-here
python -m pytest tests/ -vWith TP_DEV_TOKEN set, the SDK picked it up automatically — no hardcoded credentials in test files.
Step 5: Mobile Testing Setup (Appium)
TestProject's mobile support required additional prerequisites beyond the agent:
For Android:
- Android SDK installed (
adbin PATH) - Android emulator running or physical device connected via USB
- USB debugging enabled on device
For iOS (macOS only):
- Xcode installed
- iOS Simulator or physical device connected
libimobiledeviceinstalled (brew install libimobiledevice)
Appium Server Configuration
TestProject's agent included an embedded Appium server, so you didn't install Appium separately. The agent started Appium automatically when a mobile job was triggered.
Android SDK Test
from src.testproject.sdk.drivers import webdriver
from selenium.webdriver.common.by import By
def test_android_login():
"""Test login screen on Android emulator."""
desired_caps = {
"platformName": "Android",
"platformVersion": "11.0",
"deviceName": "Android Emulator",
"appPackage": "com.example.myapp",
"appActivity": ".MainActivity",
"automationName": "UiAutomator2"
}
driver = webdriver.Remote(
command_executor="http://localhost:8686/wd/hub",
desired_capabilities=desired_caps,
token=TESTPROJECT_TOKEN
)
try:
# Wait for app to load
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 15)
email_field = wait.until(
EC.presence_of_element_located((By.ID, "com.example.myapp:id/email_input"))
)
email_field.send_keys("testuser@example.com")
password_field = driver.find_element(By.ID, "com.example.myapp:id/password_input")
password_field.send_keys("testpassword123")
driver.find_element(By.ID, "com.example.myapp:id/login_button").click()
# Verify dashboard loaded
dashboard_header = wait.until(
EC.presence_of_element_located((By.ID, "com.example.myapp:id/dashboard_title"))
)
assert dashboard_header.is_displayed()
finally:
driver.quit()The port 8686 was the embedded Appium server in the TestProject agent. Port 8585 was the agent's web API.
What the Equivalent Setup Looks Like Today
TestProject is gone. For teams wanting free Selenium/Appium testing today, the closest equivalents are:
For Selenium web testing (code-based):
pip install selenium pytest
# No agent, no registration — just install and runYou lose the cloud dashboard and self-healing, but gain zero dependencies beyond Python and ChromeDriver.
For Playwright (recommended for new projects):
pip install playwright pytest-playwright
playwright install chromium
# Tests run locally; reports are HTML filesFor mobile with Appium:
npm install -g appium
appium driver install uiautomator2 # Android
appium & # Start server on :4723Then use the Appium Python client directly — the TestProject wrapper is no longer available.
For zero-infrastructure testing (monitoring-grade):
HelpMeTest skips the entire agent/driver/framework stack. Sign up, write tests in plain English, and tests run on HelpMeTest's cloud infrastructure with 24/7 monitoring. Usage-based pricing ($0.003/run) covers 5-minute check intervals — no installation required.
Test: "Go to example.com/login, enter testuser@example.com and testpassword123,
click Login, verify the dashboard header shows 'Welcome'"That's the complete test definition. No SDK, no agent, no ChromeDriver version management.
Key takeaways:
- TestProject's setup required an agent (Java process), API key, and either the Chrome recorder or OpenSDK
- The agent embedded Appium for mobile testing — no separate Appium install needed
- Docker was the recommended agent approach for CI environments
- Active alternatives: Selenium (no cloud), Playwright (recommended), Appium (mobile), HelpMeTest (zero-infrastructure)
- The OpenSDK pattern (wrap Selenium + auto-report) is reproducible with Playwright + Allure if you want similar functionality today