Kobiton tests failing? Devices slow or disconnecting? You’re not alone.

This guide covers the most common Kobiton issues users report — and how to fix them.

Slow Performance

Slow Performance Reports

“It’s very slow, and the UI can be clumsy at times.”
— Capterra review

“Sometimes the interface to the devices is slow. Also, at times, downloading data is slower than normal.”
— Capterra review

“Execution speed: Speed is slow compared to competitors, causing automated tests to fail due to connection timeouts.”
— TestAutomationTools

Kobiton performance issues typically manifest as:

  • Slow device interaction (taps, swipes take seconds)
  • Long app launch times
  • Delayed screenshot capture
  • Timeout errors during automation

Why Performance Suffers

  1. Shared device congestion: Multiple users accessing similar devices
  2. Network latency: Distance between you and Kobiton’s data center
  3. Unhealthy devices: Devices with low memory or network issues
  4. Peak hours: High demand periods slow the platform

Performance Solutions

Try a different device:

javascript 
// Instead of specifying exact device
'appium:deviceName': 'Galaxy S21'

// Use wildcard to get any available device
'appium:deviceName': '*'

Increase timeouts:

javascript 
// WebDriverIO
capabilities: {
  'appium:newCommandTimeout': 300,  // 5 minutes
}

// Or at driver level
driver.setTimeout({ implicit: 30000 });

Test during off-peak hours:

Kobiton’s shared cloud is busiest during US business hours. Early morning or late evening (US time) often has better performance.

Upgrade to dedicated devices:

Shared device issues disappear with dedicated devices — but the cost increases significantly (Enterprise tier). See our Kobiton pricing breakdown.

Device Connection Failures

Connection Failure Reports

“Historically the thing I’ve disliked the most about Kobiton is the inconsistent connectivity of its devices. I have experienced all too many instances in which shared devices either have poor connections that make interaction very slow or are just unable to connect at all.”
— SoftwareReviews

Connection errors appear as:

  • “Unable to create session”
  • “Device not available”
  • Session starts but immediately disconnects
  • “Connection timeout” during test execution

Why Connections Fail

  1. Device already in use: Another user has the device
  2. Device unhealthy: Memory full, network down, battery issues
  3. Session limit reached: Your plan’s concurrent sessions maxed
  4. Network issues: Between your machine and Kobiton

Connection Solutions

Use wildcard device selection:

javascript 
// Let Kobiton pick any available matching device
{
  platformName: 'Android',
  'appium:deviceName': '*',
  'appium:platformVersion': '12.0'
}

Check device health before testing:

In the Kobiton portal, devices show health indicators. Avoid devices with warning icons.

Implement retry logic:

javascript 
async function createSessionWithRetry(capabilities, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await remote({
        hostname: 'api.kobiton.com',
        // ... other config
        capabilities
      });
    } catch (error) {
      console.log(`Attempt ${attempt} failed: ${error.message}`);
      if (attempt === maxRetries) throw error;
      await new Promise(r => setTimeout(r, 5000)); // Wait 5s before retry
    }
  }
}

Use device groups strategically:

javascript 
// For critical tests, use organization devices (if available)
'kobiton:deviceGroup': 'ORGANIZATION'

// For general testing, public cloud
'kobiton:deviceGroup': 'KOBITON'

For setup details, see our Kobiton setup guide.

Automation Test Failures

Automation Failure Reports

“If you’re intending to run automated tests on Kobiton devices, seriously consider investing in dedicated devices. When we attempted to run Katalon tests on Kobiton’s shared devices, the connections were so inconsistent that we always had more failures than passes. In the end it wasn’t worth our time.”
— SoftwareReviews

Automation failures on Kobiton often aren’t your code — they’re infrastructure issues. This is a common problem with flaky tests.

Why Automation Fails

  1. Shared device instability: Connection drops mid-test
  2. Device state pollution: Previous session left apps or settings
  3. Timeout mismatches: Kobiton’s timeouts shorter than test needs
  4. Element timing: Slow devices make elements appear late

Automation Solutions

Add explicit waits:

javascript 
// Don't rely on implicit waits alone
const element = await driver.$('~login_button');
await element.waitForDisplayed({ timeout: 30000 });
await element.click();

Clean device state at test start:

javascript 
// Reset app state
capabilities: {
  'appium:noReset': false,
  'appium:fullReset': true  // Warning: slower but cleaner
}

Use try-catch with meaningful errors:

javascript 
try {
  await loginButton.click();
} catch (error) {
  // Capture screenshot on failure
  const screenshot = await driver.takeScreenshot();
  console.error('Failed to click login. Screenshot:', screenshot);
  throw error;
}

Consider dedicated devices for CI:

For CI/CD pipelines where reliability is critical, shared devices’ inconsistency may not be acceptable. Evaluate whether the cost of dedicated devices or an alternative platform is justified.

Unhealthy Device Issues

Unhealthy Device Reports

“At times, some public cloud devices will not be healthy (no memory, no network, etc) which will fail the tests randomly.”
— Capterra review

Symptoms:

  • App crashes immediately after launch
  • “App not responding” errors
  • Network requests fail
  • Device becomes unresponsive mid-test

Why Devices Become Unhealthy

  1. Memory exhaustion: Previous sessions didn’t clean up
  2. Network configuration: Device lost connectivity
  3. Battery issues: Charging problems on physical devices
  4. OS instability: Device needs restart

Unhealthy Device Solutions

Check device health in portal:

Before selecting a device, view its status. Avoid devices showing warnings.

Use explicit app reset:

javascript 
{
  'appium:noReset': false,
  'appium:fullReset': false  // Reinstalls app but keeps device data
}

Report unhealthy devices:

Use Kobiton’s support to report consistently problematic devices. They can be removed from the pool for maintenance.

Switch to different device mid-pipeline:

javascript 
const devices = ['Galaxy S21', 'Galaxy S22', 'Pixel 6'];

for (const device of devices) {
  try {
    const driver = await createSession({ 'appium:deviceName': device });
    await runTests(driver);
    await driver.quit();
    break; // Success, exit loop
  } catch (error) {
    console.log(`${device} failed, trying next...`);
  }
}

iOS-Specific Issues

Apple ID Login Required

“When I use iOS devices it usually requires me to log into my Apple ID to download apps from the app store.”
— Capterra review

Cause: Shared iOS devices can’t maintain persistent Apple ID sessions.

Solutions:

  1. Upload apps to Kobiton store instead of downloading from App Store
  2. Use your kobiton-store URL in capabilities:
    javascript 
    'kobiton:app': 'kobiton-store:v657531'
  3. Test with pre-installed apps if possible

Pattern Lock Screen

“Sometimes I cannot even get into the store. It will ask for a pattern code to be entered.”
— Capterra review

Cause: Shared devices may have security settings from previous sessions.

Solutions:

  1. Select a different device
  2. Report the device to Kobiton support
  3. Wait — device may auto-reset after a period

iOS Signing Errors

Symptoms:

  • “Unable to install app”
  • “Code signature invalid”
  • “Provisioning profile doesn’t include device”

Solutions:

  1. Add signing capabilities:

    javascript 
    {
  'appium:xcodeOrgId': 'YOUR_TEAM_ID',
  'appium:xcodeSigningId': 'iPhone Developer'
}

  2. Verify Team ID from Apple Developer Portal

  3. Use Ad Hoc or Enterprise distribution for broader device compatibility

Note that iOS entitlements may be stripped when apps are re-signed for cloud testing.

Session Management Issues

Session Doesn’t Start

Error: “Unable to create new session”

Solutions:

  1. Verify credentials:

    javascript 
    console.log('Username:', process.env.KOBITON_USERNAME);
// Don't log API key, but verify it's set
console.log('API Key set:', !!process.env.KOBITON_API_KEY);

  2. Check capability syntax:

    javascript 
    // Appium 2 requires prefixes
'appium:deviceName': 'Galaxy S21',  // ✓ Correct
'deviceName': 'Galaxy S21',          // ✗ May fail

  3. Verify app exists:

    • Check kobiton-store:vXXXXXX is valid
    • Re-upload if needed

Session Ends Unexpectedly

Cause: Session timeout or device disconnection

Solutions:

  1. Extend timeout:

    javascript 
    'appium:newCommandTimeout': 600  // 10 minutes

  2. Keep session alive with periodic commands:

    javascript 
    // In long-running tests, periodically interact
await driver.getWindowSize();

  3. Check for session quota: Your plan may limit concurrent sessions

Minutes Running Out

Minutes Problem Reports

“Time based plans and when we move on to large automations we need to buy expensive plans.”
— G2 review

Per-minute billing means every test run costs money. Retries, debugging, and failed attempts all consume minutes.

Minutes Solutions

Optimize test efficiency:

  • Reduce unnecessary waits
  • Parallelize where possible
  • Skip redundant setup steps

Monitor usage:

  • Check minutes remaining in portal
  • Set up alerts before running out

Consider alternatives:

When to Consider Alternatives

Some Kobiton issues aren’t fixable — they’re inherent to the platform model.

Consider alternatives when:

  • Shared device failures exceed 10% of tests — Infrastructure reliability is the problem
  • Per-minute costs are unpredictable — Your budget can’t handle variable billing
  • You need web testing — Kobiton is mobile-focused
  • Device variety is insufficient — 350+ devices may not cover your needs

See our Kobiton alternatives guide or Kobiton vs BrowserStack comparison for options.

Quick Troubleshooting Checklist

Issue Quick Fix
Slow performance Try different device, increase timeouts
Connection failure Use wildcard device, add retry logic
Automation flaky Use dedicated devices, add explicit waits
Unhealthy device Switch devices, report to support
iOS login required Upload to kobiton-store instead
Session timeout Increase newCommandTimeout
App not found Verify kobiton-store URL
Authentication failed Check username (not email) and API key

Frequently Asked Questions

Why is Kobiton so slow?

Kobiton slowness typically comes from shared device congestion, network latency to their cloud, or unhealthy devices. Try selecting a different device, testing during off-peak hours, or upgrading to dedicated devices to eliminate shared device issues.

Why do my Kobiton automation tests keep failing?

Shared device connection instability is the most common cause. Users report “more failures than passes” on shared devices. Solutions include using dedicated devices, increasing timeouts, adding retry logic, or switching to a more stable platform.

Why won’t Kobiton connect to a device?

Device connection failures happen when devices are unhealthy (no memory, no network), already in use, or experiencing connectivity issues. Try a different device, check device health status in the portal, or use wildcard device selection.

How do I fix Kobiton iOS App Store access issues?

iOS devices may require Apple ID login for App Store access, or show pattern lock screens. This is a limitation of shared devices. For consistent iOS testing, use dedicated devices or test with apps installed via kobiton-store URLs.

Why are my Kobiton test results inconsistent?

Inconsistent results usually stem from shared device state issues — previous sessions may leave apps installed, change settings, or consume resources. Use dedicated devices, or add explicit cleanup steps at test start.

Getting More Help

Tired of troubleshooting shared device issues? DeviceLab runs tests on your own devices — no shared infrastructure, no connection lottery, no per-minute surprises. Get started.