# API Reference
Source: https://docs.nativebridge.io/api-reference

Programmatically manage your apps and automate testing workflows with the NativeBridge REST API

# API Reference

The NativeBridge REST API enables you to programmatically upload apps, manage builds, generate magic links, and automate your mobile testing workflows.

<Card href="https://documenter.getpostman.com/view/41713518/2sAYkGLf4d" target="_blank">
  <div className="flex items-center justify-between">
    <div>
      <h3 className="text-lg font-semibold mb-2">📚 Full API Documentation</h3>

      <p className="text-gray-600 dark:text-gray-400">
        View our complete API reference with interactive examples on Postman
      </p>
    </div>

    <Icon icon="external-link" size={24} />
  </div>
</Card>

## Key Features

<CardGroup cols={2}>
  <Card title="App Management" icon="upload">
    Upload, update, and manage your app builds programmatically
  </Card>

  <Card title="Magic Links" icon="link">
    Auto-generate shareable magic links for every build
  </Card>

  <Card title="CI/CD Integration" icon="code-branch">
    Integrate with GitHub Actions, GitLab CI, and other pipelines
  </Card>

  <Card title="Automation" icon="robot">
    Run automated tests with Appium and Maestro
  </Card>
</CardGroup>

## Quick Start

### Authentication

All API requests require authentication using your API key:

```bash
curl -X POST https://api.nativebridge.dev/v1/apps \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"
```

<Info>
  Get your API key from the [Dashboard](https://nativebridge.io/settings/api-keys) → Settings → API Keys
</Info>

### Upload Your First App

```bash
curl -X POST https://api.nativebridge.dev/v1/apps/upload \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@path/to/your/app.apk" \
  -F "platform=android"
```

The response includes your magic link:

```json
{
  "appId": "abc123",
  "magicLink": "https://nativebridge.io/app/abc123",
  "embedUrl": "https://nativebridge.io/embed/abc123",
  "status": "ready"
}
```

## CI/CD Integration

### Auto-Generate Magic Links on Every Push

Automatically create magic links for every commit to get instant preview links for your team:

#### GitHub Actions Example

```yaml
name: Deploy to NativeBridge

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Build App
        run: |
          # Your build commands here
          ./gradlew assembleDebug  # Android
          # or
          # xcodebuild -scheme YourApp  # iOS

      - name: Upload to NativeBridge
        id: upload
        run: |
          response=$(curl -X POST https://api.nativebridge.dev/v1/apps/upload \
            -H "Authorization: Bearer ${{ secrets.NATIVEBRIDGE_API_KEY }}" \
            -F "file=@app/build/outputs/apk/debug/app-debug.apk" \
            -F "platform=android" \
            -F "buildMessage=${{ github.event.head_commit.message }}")

          echo "response=$response" >> $GITHUB_OUTPUT
          magic_link=$(echo $response | jq -r '.magicLink')
          echo "magic_link=$magic_link" >> $GITHUB_OUTPUT

      - name: Comment PR with Magic Link
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v6
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `🚀 **App Preview Ready!**\n\nTest this build: ${{ steps.upload.outputs.magic_link }}\n\n_Powered by NativeBridge_`
            })
```

### Auto-Generate Links for Pull Requests

Create preview apps for every PR to streamline code reviews:

#### GitLab CI Example

```yaml
deploy_preview:
  stage: deploy
  script:
    - |
      # Build your app
      ./gradlew assembleDebug

      # Upload to NativeBridge
      RESPONSE=$(curl -X POST https://api.nativebridge.dev/v1/apps/upload \
        -H "Authorization: Bearer $NATIVEBRIDGE_API_KEY" \
        -F "file=@app/build/outputs/apk/debug/app-debug.apk" \
        -F "platform=android" \
        -F "buildMessage=PR: $CI_MERGE_REQUEST_TITLE")

      # Extract magic link
      MAGIC_LINK=$(echo $RESPONSE | jq -r '.magicLink')

      # Post comment to MR
      curl -X POST "$CI_API_V4_URL/projects/$CI_PROJECT_ID/merge_requests/$CI_MERGE_REQUEST_IID/notes" \
        -H "PRIVATE-TOKEN: $GITLAB_TOKEN" \
        -d "body=🚀 **Preview App Ready**: $MAGIC_LINK"

  only:
    - merge_requests
```

## Common API Endpoints

### Core Operations

| Endpoint                       | Method | Description                         |
| ------------------------------ | ------ | ----------------------------------- |
| `/v1/apps/upload`              | POST   | Upload a new app or update existing |
| `/v1/apps/{appId}`             | GET    | Get app details and magic link      |
| `/v1/apps/{appId}/builds`      | GET    | List all builds for an app          |
| `/v1/apps/{appId}`             | DELETE | Delete an app                       |
| `/v1/apps/{appId}/permissions` | PUT    | Update app permissions              |

### Automation & Testing

| Endpoint                              | Method | Description                 |
| ------------------------------------- | ------ | --------------------------- |
| `/v1/sessions/start`                  | POST   | Start a new testing session |
| `/v1/sessions/{sessionId}/screenshot` | GET    | Capture screenshot          |
| `/v1/sessions/{sessionId}/logs`       | GET    | Get device logs             |
| `/v1/sessions/{sessionId}/stop`       | POST   | End testing session         |

<Info>
  For complete endpoint documentation, request/response schemas, and interactive examples, visit our [Postman Documentation](https://documenter.getpostman.com/view/41713518/2sAYkGLf4d)
</Info>

## Use Cases

### 1. Continuous Deployment

Automatically deploy every commit:

```javascript
// Node.js Example
const FormData = require('form-data');
const fs = require('fs');

async function deployToNativeBridge(appPath, commitMessage) {
  const form = new FormData();
  form.append('file', fs.createReadStream(appPath));
  form.append('platform', 'ios');
  form.append('buildMessage', commitMessage);

  const response = await fetch('https://api.nativebridge.dev/v1/apps/upload', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.NATIVEBRIDGE_API_KEY}`,
      ...form.getHeaders()
    },
    body: form
  });

  const result = await response.json();
  console.log(`Magic Link: ${result.magicLink}`);
  return result;
}
```

### 2. Nightly Build Distribution

Share nightly builds with your QA team:

```python
# Python Example
import requests
import schedule
import time

def upload_nightly_build():
    with open('app-nightly.apk', 'rb') as f:
        files = {'file': f}
        data = {
            'platform': 'android',
            'buildMessage': f'Nightly Build - {time.strftime("%Y-%m-%d")}'
        }
        headers = {
            'Authorization': f'Bearer {API_KEY}'
        }

        response = requests.post(
            'https://api.nativebridge.dev/v1/apps/upload',
            files=files,
            data=data,
            headers=headers
        )

        magic_link = response.json()['magicLink']
        send_slack_notification(magic_link)  # Share with team

# Schedule nightly at 2 AM
schedule.every().day.at("02:00").do(upload_nightly_build)
```

### 3. Feature Branch Previews

Create previews for each feature branch:

```bash
#!/bin/bash
# deploy-preview.sh

BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
BUILD_MESSAGE="Feature: $BRANCH_NAME"

# Build app
./gradlew assembleDebug

# Upload and get magic link
RESPONSE=$(curl -s -X POST https://api.nativebridge.dev/v1/apps/upload \
  -H "Authorization: Bearer $NATIVEBRIDGE_API_KEY" \
  -F "file=@app/build/outputs/apk/debug/app-debug.apk" \
  -F "platform=android" \
  -F "buildMessage=$BUILD_MESSAGE")

MAGIC_LINK=$(echo $RESPONSE | jq -r '.magicLink')

echo "✅ Preview ready: $MAGIC_LINK"

# Update PR description or send to Slack
```

## Best Practices

<Tabs>
  <Tab title="Security">
    * Store API keys in environment variables or secrets management
    * Never commit API keys to version control
    * Use different API keys for production and development
    * Rotate API keys regularly
  </Tab>

  <Tab title="Performance">
    * Compress app files before uploading
    * Use parallel uploads for multiple platforms
    * Implement retry logic for network failures
    * Cache magic links to avoid redundant API calls
  </Tab>

  <Tab title="Organization">
    * Use meaningful build messages for easy identification
    * Tag builds with version numbers and commit hashes
    * Set appropriate expiration for preview links
    * Clean up old builds periodically
  </Tab>
</Tabs>

## Rate Limits

| Plan    | Requests/Hour | Concurrent Uploads | Max App Size |
| ------- | ------------- | ------------------ | ------------ |
| Free    | 60            | 1                  | 100 MB       |
| Starter | 300           | 3                  | 500 MB       |
| Growth  | 1000          | 10                 | 1 GB         |
| Custom  | Unlimited     | Unlimited          | Unlimited    |

## Error Handling

Common error responses and solutions:

```json
{
  "error": "INVALID_FILE_FORMAT",
  "message": "File must be .apk, .app, or .ipa",
  "solution": "Ensure you're uploading a valid app file"
}
```

<AccordionGroup>
  <Accordion title="401 Unauthorized">
    Check that your API key is valid and included in the Authorization header
  </Accordion>

  <Accordion title="413 File Too Large">
    Compress your app or upgrade to a higher plan for larger file limits
  </Accordion>

  <Accordion title="429 Rate Limited">
    You've exceeded the rate limit. Wait and retry or upgrade your plan
  </Accordion>

  <Accordion title="500 Server Error">
    Temporary issue on our end. Retry with exponential backoff
  </Accordion>
</AccordionGroup>

## SDK & Libraries

<CardGroup cols={3}>
  <Card title="Node.js SDK" icon="node-js" href="https://npmjs.com/package/nativebridge">
    npm install nativebridge
  </Card>

  <Card title="Python SDK" icon="python" href="https://pypi.org/project/nativebridge">
    pip install nativebridge
  </Card>

  <Card title="GitHub Action" icon="github" href="https://github.com/marketplace/actions/nativebridge-upload">
    Official GitHub Action
  </Card>
</CardGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="View Full API Docs" icon="book" href="https://documenter.getpostman.com/view/41713518/2sAYkGLf4d">
    Explore all endpoints with examples
  </Card>

  <Card title="Get API Key" icon="key" href="https://nativebridge.io/settings/api-keys">
    Generate your API key to get started
  </Card>

  <Card title="Test Automation" icon="robot" href="/testing/test-automation">
    Automation and CI/CD integration
  </Card>

  <Card title="Support" icon="headset" href="mailto:contact@autoflowapp.com">
    Get help with API integration
  </Card>
</CardGroup>


# Getting Your API Key
Source: https://docs.nativebridge.io/getting-api-key

Generate and manage API keys to access NativeBridge REST API

# Getting Your API Key

API keys allow you to programmatically interact with NativeBridge, enabling you to upload apps, generate magic links, and automate your testing workflows.

<Info>
  API keys are tied to your organization and have the same permissions as your user account. Keep them secure and never share them publicly.
</Info>

## Generate Your First API Key

Follow these simple steps to create your API key:

<Steps>
  <Step title="Navigate to Dashboard">
    Log in to your NativeBridge account and go to your [Dashboard](https://nativebridge.io/dashboard)
  </Step>

  <Step title="Access API Keys Section">
    Click on **"API Keys"** in the sidebar navigation or go directly to [API Keys](https://nativebridge.io/settings/api-keys)
  </Step>

  <Step title="Create New API Key">
    Click the **"Generate New API Key"** button
  </Step>

  <Step title="Name Your Key">
    Give your API key a descriptive name (e.g., "GitHub Actions", "Development", "Production")
  </Step>

  <Step title="Copy and Save">
    Copy your API key immediately - you won't be able to see it again once you leave the page
  </Step>
</Steps>

<Warning>
  **Important:** Your API key will only be shown once. Make sure to copy and store it securely before navigating away from the page.
</Warning>

## Visual Guide

<Frame />

The API Keys section in your dashboard shows:

* List of all active API keys
* When each key was created
* Last used timestamp
* Options to revoke keys

## Using Your API Key

Once you have your API key, you can use it in your API requests:

### In HTTP Headers

```bash
curl -X POST https://api.nativebridge.dev/v1/apps/upload \
  -H "Authorization: Bearer YOUR_API_KEY_HERE" \
  -F "file=@app.apk" \
  -F "platform=android"
```

### In Environment Variables

Store your API key as an environment variable for security:

```bash
# .env file
NATIVEBRIDGE_API_KEY=your_api_key_here
```

```javascript
// Node.js
const apiKey = process.env.NATIVEBRIDGE_API_KEY;

const response = await fetch('https://api.nativebridge.dev/v1/apps/upload', {
  headers: {
    'Authorization': `Bearer ${apiKey}`
  }
});
```

### In CI/CD Pipelines

#### GitHub Actions

1. Go to your repository Settings → Secrets → Actions
2. Add a new secret named `NATIVEBRIDGE_API_KEY`
3. Use in your workflow:

```yaml
- name: Upload to NativeBridge
  run: |
    curl -X POST https://api.nativebridge.dev/v1/apps/upload \
      -H "Authorization: Bearer ${{ secrets.NATIVEBRIDGE_API_KEY }}" \
      -F "file=@app.apk"
```

#### GitLab CI

1. Go to Project Settings → CI/CD → Variables
2. Add a variable named `NATIVEBRIDGE_API_KEY`
3. Use in your pipeline:

```yaml
upload_app:
  script:
    - curl -X POST https://api.nativebridge.dev/v1/apps/upload \
        -H "Authorization: Bearer $NATIVEBRIDGE_API_KEY" \
        -F "file=@app.apk"
```

## Managing API Keys

### View All Keys

Your [API Keys dashboard](https://nativebridge.io/settings/api-keys) displays:

| Column    | Description                           |
| --------- | ------------------------------------- |
| Name      | The descriptive name you gave the key |
| Created   | When the key was generated            |
| Last Used | Most recent API call using this key   |
| Actions   | Revoke or regenerate the key          |

### Revoke a Key

To revoke an API key:

1. Go to [API Keys](https://nativebridge.io/settings/api-keys)
2. Find the key you want to revoke
3. Click the **"Revoke"** button
4. Confirm the action

<Warning>
  Revoking a key immediately invalidates it. Any services using this key will lose access.
</Warning>

### Regenerate a Key

If you suspect a key has been compromised:

1. Revoke the compromised key immediately
2. Generate a new key with the same name
3. Update all services with the new key

## Best Practices

<Cards>
  <Card title="Use Descriptive Names" icon="tag">
    Name keys based on their purpose: "Production API", "GitHub Actions", "Local Development"
  </Card>

  <Card title="Rotate Regularly" icon="refresh">
    Rotate API keys every 90 days for enhanced security
  </Card>

  <Card title="Limit Scope" icon="shield">
    Create separate keys for different environments (dev, staging, production)
  </Card>

  <Card title="Never Commit Keys" icon="lock">
    Never commit API keys to version control - use environment variables instead
  </Card>
</Cards>

## Security Guidelines

### DO ✅

* Store keys in environment variables or secrets management systems
* Use different keys for different environments
* Revoke unused or compromised keys immediately
* Monitor key usage in your dashboard
* Use HTTPS for all API requests

### DON'T ❌

* Share keys in emails or chat messages
* Commit keys to git repositories
* Use the same key across multiple projects
* Expose keys in client-side code
* Log or print keys in console output

## Rate Limits by Plan

API keys inherit the rate limits of your subscription plan:

| Plan    | API Calls/Hour | Concurrent Requests |
| ------- | -------------- | ------------------- |
| Free    | 60             | 1                   |
| Starter | 300            | 3                   |
| Growth  | 1000           | 10                  |
| Custom  | Unlimited      | Unlimited           |

<Info>
  Need higher limits? [Contact us](mailto:contact@autoflowapp.com) to discuss custom plans.
</Info>

## Troubleshooting

<AccordionGroup>
  <Accordion title="API Key not working">
    * Ensure you're including "Bearer " before the key in the Authorization header
    * Check that the key hasn't been revoked
    * Verify you're using the correct API endpoint
    * Make sure there are no extra spaces or characters
  </Accordion>

  <Accordion title="Can't see API Keys section">
    * Verify you have the necessary permissions in your organization
    * Check if your plan includes API access
    * Contact your organization admin for access
  </Accordion>

  <Accordion title="Forgot to copy key">
    * Once created, keys cannot be viewed again for security
    * You'll need to revoke the old key and create a new one
    * Make sure to update all services with the new key
  </Accordion>

  <Accordion title="Rate limit exceeded">
    * Check your current plan's limits in the dashboard
    * Consider upgrading to a higher plan
    * Implement request caching and batching
  </Accordion>
</AccordionGroup>

## Example: Your First API Call

Once you have your API key, try this simple test:

```bash
# Test your API key
curl -X GET https://api.nativebridge.dev/v1/account \
  -H "Authorization: Bearer YOUR_API_KEY_HERE"

# Expected response:
{
  "organization": "Your Organization",
  "plan": "starter",
  "api_calls_remaining": 298
}
```

## Next Steps

<CardGroup cols={2}>
  <Card title="API Reference" icon="book" href="/api-reference">
    Explore all available API endpoints
  </Card>

  <Card title="Upload Your First App" icon="upload" href="/platform/app-management/uploading-apps/uploading-apps">
    Start uploading apps via API
  </Card>

  <Card title="CI/CD Integration" icon="code-branch" href="/api-reference#cicd-integration">
    Automate with GitHub Actions & GitLab
  </Card>

  <Card title="Postman Collection" icon="external-link" href="https://documenter.getpostman.com/view/41713518/2sAYkGLf4d">
    Interactive API documentation
  </Card>
</CardGroup>


# Introduction
Source: https://docs.nativebridge.io/index

Run, Test & Develop real iOS and Android apps directly in your browser & IDE(Like VSCode & Cursor) with NativeBridge - no downloads, installations, or extra permissions needed!

## Why NativeBridge?

NativeBridge is a cloud-powered platform that lets developers and teams launch, test, and interact with their mobile apps on real & virtual devices straight from the web.

Built to be fast, flexible, and intuitive, NativeBridge is the go-to solution for a variety of use cases, including:

<CardGroup cols={3}>
  <Card title="Live App Previews" icon="globe">
    Share your app instantly with stakeholders via secure links. Preview builds in real-time across multiple devices without deployment delays
  </Card>

  <Card title="Mobile Testing" icon="shield-check">
    Test on 50+ real devices running actual OS versions. Catch device-specific bugs before your users do with comprehensive testing coverage
  </Card>

  <Card title="Mobile Demos" icon="bolt">
    Showcase your app to clients and investors without app store downloads. Launch interactive demos in seconds directly from your browser
  </Card>

  <Card title="Test Automation" icon="code">
    Run Appium and Maestro scripts at scale. Automate your entire QA pipeline with parallel execution across multiple device configurations
  </Card>

  <Card title="Training & Onboarding" icon="badge-check">
    Onboard new team members 10x faster with hands-on app walkthroughs. Create interactive training sessions without device provisioning
  </Card>

  <Card title="Embedded Previews" icon="puzzle-piece">
    Embed live app experiences directly into your documentation, landing pages, or support portals with just an iframe
  </Card>
</CardGroup>

Ready to see NativeBridge in action? Get started in just a few clicks - upload your app or book a demo with us.

## Upload your first App

The easiest way to begin with NativeBridge is to upload your app. Follow along at:

<Card title="App Upload Guide" icon="upload" href="/platform/app-management/uploading-apps/uploading-apps">
  Learn how to upload your iOS or Android app and configure settings for optimal performance
</Card>

## Run & Test your App

Once your app is uploaded, you can instantly run and test your app with powerful debugging capabilities.

<CardGroup cols={2}>
  <Card title="Running & Testing Apps" icon="play-circle" href="/platform/app-management/running-and-testing-apps">
    Launch your app instantly and test across multiple devices with real-time interaction
  </Card>

  <Card title="Debugging Tools" icon="bug" href="/platform/app-management/debugging-tools">
    Access comprehensive debugging tools including ADB, shell access, and system logs
  </Card>
</CardGroup>

## Share and Embed your App

You can also embed and share your app with clients and other stakeholders with just a click.

<Card title="Embedding Apps" icon="code" href="/platform/app-management/embedding-apps">
  Embed live app experiences in your website or documentation with our iframe integration
</Card>

## Running Automated Tests

NativeBridge makes it super simple to run automated tests on any device that you want.

<Card title="Test Automation" icon="robot" href="/testing/test-automation">
  Set up and run Appium & Maestro tests across multiple devices with our automation platform
</Card>

## Monitor Your Activity

Track all your testing activities and app automation runs in one centralized location.

<Card title="Activity Dashboard" icon="chart-line" href="/platform/app-management/activity-dashboard">
  Monitor all your test runs, sessions, and automation logs with comprehensive analytics
</Card>

<Note>
  **Need enterprise support?** Contact us at [contact@autoflowapp.com](mailto:contact@autoflowapp.com) for dedicated support, custom modules, and training.
</Note>


# Activity Dashboard
Source: https://docs.nativebridge.io/platform/app-management/activity-dashboard

Centralized hub for monitoring, analyzing, and managing all device sessions and test automation runs with comprehensive logging and reporting capabilities.

## Overview

The Activity Dashboard provides a comprehensive view of all your testing activities, enabling you to track performance, identify issues, and optimize your testing workflow. Access detailed logs, session recordings, and analytics for both manual device sessions and automated test runs.

## Accessing the Activity Dashboard

<Steps>
  <Step title="Navigate to Your Profile">
    Click on the profile icon located in the top-right corner of the interface
  </Step>

  <Step title="Select Activity Section">
    Choose **Activity** from the dropdown menu or navigate directly to [nativebridge.io/activity](https://nativebridge.io/activity)
  </Step>
</Steps>

## Device Sessions

### Session Management

Monitor and analyze all your device testing sessions with comprehensive tracking capabilities:

<CardGroup cols={2}>
  <Card title="Session Logs" icon="file-lines">
    Access detailed logs from each testing session including system events, user interactions, and application responses
  </Card>

  <Card title="Session Recordings" icon="video">
    Review complete video recordings of your sessions for debugging and quality assurance purposes
  </Card>

  <Card title="Device Information" icon="mobile">
    Track device specifications, OS versions, and hardware configurations used during testing
  </Card>

  <Card title="Usage Analytics" icon="chart-line">
    Monitor session duration, interaction patterns, and resource utilization metrics
  </Card>
</CardGroup>

### Key Features

* **Real-time Monitoring**: Track active sessions as they occur
* **Historical Data**: Access archived sessions for compliance and analysis
* **Search & Filter**: Quickly locate specific sessions using advanced filters
* **Export Capabilities**: Download logs and reports for offline analysis

## Test Automation Analytics

### Comprehensive Test Reporting

Gain deep insights into your automated testing processes with advanced analytics:

<CardGroup cols={2}>
  <Card title="Test Reports" icon="clipboard-check">
    Detailed pass/fail analysis with execution timelines and error diagnostics
  </Card>

  <Card title="Execution Logs" icon="terminal">
    Complete command-line outputs, API responses, and system messages
  </Card>

  <Card title="Video Evidence" icon="play-circle">
    Visual recordings of automated test executions for verification
  </Card>

  <Card title="Framework Details" icon="code">
    Information about testing frameworks, libraries, and configurations used
  </Card>
</CardGroup>

### Analytics Dashboard Features

* **Test Suite Overview**: Aggregate statistics across all test runs
* **Failure Analysis**: Identify patterns and common failure points
* **Performance Metrics**: Track execution times and resource consumption
* **Integration Data**: Monitor CI/CD pipeline integration status

## Data Management

<Tabs>
  <Tab title="Retention Policies">
    * Session logs retained for 30 days
    * Video recordings available for 14 days
    * Test reports archived for 90 days
    * Custom retention available for enterprise plans
  </Tab>

  <Tab title="Export Options">
    * **CSV Export**: Structured data for spreadsheet analysis
    * **JSON Format**: Machine-readable format for integration
    * **PDF Reports**: Professional documentation for stakeholders
    * **Video Downloads**: MP4 format for offline review
  </Tab>

  <Tab title="Access Control">
    * Role-based permissions for sensitive data
    * Team member access management
    * Audit trail for all data access
    * Compliance with data protection regulations
  </Tab>
</Tabs>

## Best Practices

### Optimizing Dashboard Usage

<AccordionGroup>
  <Accordion title="Regular Review Cycles">
    Establish routine review periods to analyze testing patterns and identify optimization opportunities. Weekly reviews help maintain testing quality and efficiency.
  </Accordion>

  <Accordion title="Automated Alerting">
    Configure alerts for failed tests, unusual session durations, or resource threshold breaches to enable proactive issue resolution.
  </Accordion>

  <Accordion title="Data-Driven Decisions">
    Leverage dashboard metrics to inform test strategy, device selection, and resource allocation decisions based on historical performance data.
  </Accordion>

  <Accordion title="Team Collaboration">
    Share dashboard access with relevant team members to foster collaborative debugging and knowledge sharing across your organization.
  </Accordion>
</AccordionGroup>

## Advanced Features

<Note>
  **Pro Tip**: Use the Activity Dashboard's API endpoints to integrate session data with your existing monitoring and analytics tools for enhanced visibility.
</Note>

### Custom Dashboards

Create personalized views focusing on metrics most relevant to your team:

* Filter by project or application
* Set custom date ranges
* Save frequently used queries
* Schedule automated reports

### Performance Benchmarking

Compare current test results against historical baselines:

* Track performance trends over time
* Identify regression patterns
* Monitor improvement initiatives
* Generate executive summaries

## Troubleshooting

<Warning>
  If you experience issues accessing session data or recordings, verify your account permissions and check the retention period for the requested data.
</Warning>

### Common Issues and Solutions

| Issue                      | Solution                                            |
| -------------------------- | --------------------------------------------------- |
| Missing session recordings | Check if recordings are enabled in project settings |
| Incomplete test logs       | Ensure proper test framework integration            |
| Slow dashboard loading     | Try filtering to a smaller date range               |
| Export failures            | Verify available storage quota                      |

## Related Resources

The Activity Dashboard integrates with various platform features. For additional help, please contact your system administrator or check the main platform documentation.


# App Dashboard
Source: https://docs.nativebridge.io/platform/app-management/app-dashboard

Use the App Dashboard in NativeBridge to organize and manage your apps efficiently.

<Note>For our enterprise customers we also provide Dedicated App Dashboard which'll show all of the apps within the organisation at a same place.</Note>

The **App Dashboard** shows the most recent build uploaded for a selected application.

From this page, you can:

* **Search** for apps by name or identifier
* **Filter** apps by device type (Android or iOS)
* Open the [**App Builds**](#app-builds-page) page to view all builds linked to an application
* **Play** the latest build of an application
* **Share** the latest build of an application

## App Builds Page

The **App Builds** page lists all builds uploaded for a specific application. Builds are organized by version and build details provided by the platform.

From this page, you can:

* View a summary of the [latest build](#user-content-fn-1) for the application
  * Quickly **run**, **embed**, or **share** the build using magic link
  * **Remove** the application if needed
* **Search** for builds using metadata such as version name, tags, notes, or build ID
* **Upload** a new build
* Open an individual [App Build Page](#app-build-page)
* **Play** the latest build of the application
* **Share** the latest build of the application
* **Favorite** frequently used apps


# Debugging Tools
Source: https://docs.nativebridge.io/platform/app-management/debugging-tools

Comprehensive suite of professional debugging and diagnostic tools for mobile application development, testing, and troubleshooting

## Overview

NativeBridge provides an enterprise-grade debugging toolkit that gives developers and QA engineers unprecedented access to mobile devices for comprehensive application analysis. Our debugging suite offers the same level of control as physical device access, enabling efficient troubleshooting, performance optimization, and quality assurance workflows.

<CardGroup cols={2}>
  <Card title="Real Device Access" icon="mobile-screen">
    Direct interaction with actual iOS and Android devices in the cloud
  </Card>

  <Card title="Advanced Diagnostics" icon="microscope">
    Professional-grade tools for deep system analysis and debugging
  </Card>

  <Card title="File Management" icon="folder-tree">
    Complete file system access for data inspection and manipulation
  </Card>

  <Card title="Remote Development" icon="code">
    Full ADB connectivity for development and debugging workflows
  </Card>
</CardGroup>

## Core Debugging Features

### File Transfer System

#### Send Files to Device

Transfer any file type directly to your test device for comprehensive testing scenarios:

<Steps>
  <Step title="Access File Transfer">
    Navigate to the **Send files to device** button on the session screen or magic link page
  </Step>

  <Step title="Select Files">
    Choose single or multiple files from your local system (supports drag-and-drop)
  </Step>

  <Step title="Configure Destination">
    Specify the target directory on the device or use default app storage
  </Step>

  <Step title="Transfer & Verify">
    Monitor transfer progress and verify file integrity on the device
  </Step>
</Steps>

**Use Cases:**

* Test document imports and exports
* Validate file handling capabilities
* Load test data and configurations
* Deploy debug certificates and profiles

<Note>
  **File Size Limits**: Standard plans support files up to 100MB. Enterprise plans have unlimited file transfer capabilities.
</Note>

### Multi-App Testing Environment

#### Upload Multiple Applications

Test complex app interactions and dependencies within a single session:

<Tabs>
  <Tab title="Setup Process">
    1. Launch your primary application session
    2. Click **Upload Another App** in the control panel
    3. Select additional APK/IPA files to install
    4. Apps install sequentially with progress tracking
    5. Switch between apps seamlessly during testing
  </Tab>

  <Tab title="Common Scenarios">
    * **Deep Linking**: Test app-to-app navigation flows
    * **OAuth Flows**: Validate authentication with provider apps
    * **Data Sharing**: Verify content sharing between applications
    * **Compatibility**: Check for conflicts or interference
    * **Integration Testing**: Validate third-party SDK behaviors
  </Tab>

  <Tab title="Limitations">
    | Plan Type    | Max Apps  | Storage   |
    | ------------ | --------- | --------- |
    | Starter      | 2 apps    | 500MB     |
    | Professional | 5 apps    | 2GB       |
    | Enterprise   | Unlimited | Unlimited |
  </Tab>
</Tabs>

### Device Shell Access

#### Command-Line Interface

Direct terminal access to device systems for advanced debugging:

<AccordionGroup>
  <Accordion title="Shell Capabilities">
    * **System Commands**: Execute standard Unix/Linux commands
    * **Process Management**: Monitor and control running processes
    * **Network Diagnostics**: Run ping, netstat, and trace commands
    * **Package Management**: Install, update, and remove packages
    * **Permission Inspection**: Review and modify app permissions
  </Accordion>

  <Accordion title="Access Levels">
    Different permission tiers based on your subscription:

    **Basic Access:**

    * Read-only system information
    * Application-specific directories
    * Basic network diagnostics

    **Advanced Access:**

    * Write permissions to app directories
    * Process manipulation capabilities
    * Extended system diagnostics

    **Root Access (Enterprise):**

    * Full system access
    * Kernel-level debugging
    * System file modifications
  </Accordion>

  <Accordion title="Security Considerations">
    * All shell sessions are logged and audited
    * Isolated environments prevent cross-contamination
    * Automatic session timeouts for security
    * Encrypted command transmission
  </Accordion>
</AccordionGroup>

<Warning>
  **Security Notice**: Shell access is monitored and logged. Attempting to access restricted areas or perform unauthorized operations will result in immediate session termination.
</Warning>

### File System Explorer

#### Visual File Management

Browse and manage device file systems through an intuitive interface:

<CardGroup cols={2}>
  <Card title="Navigation Features" icon="compass">
    * Hierarchical directory browsing
    * Quick search and filtering
    * Breadcrumb navigation
    * Bookmark frequently used paths
  </Card>

  <Card title="File Operations" icon="edit">
    * Create, rename, and delete files
    * Edit text files in-browser
    * View image and media files
    * Download files to local system
  </Card>

  <Card title="Advanced Tools" icon="wrench">
    * Batch operations support
    * File permission management
    * Symbolic link creation
    * Archive extraction and creation
  </Card>

  <Card title="Integration" icon="plug">
    * Direct ADB file push/pull
    * Clipboard synchronization
    * Drag-and-drop upload
    * Context menu actions
  </Card>
</CardGroup>

### System Logging

#### Comprehensive Log Management

Access and analyze all system and application logs in real-time:

<Tabs>
  <Tab title="Log Levels">
    ```
    VERBOSE  - All messages including debug details
    DEBUG    - Debugging messages and application flow
    INFO     - Informational messages and events
    WARNING  - Potentially harmful situations
    ERROR    - Error events and exceptions
    FATAL    - Critical errors causing termination
    ```
  </Tab>

  <Tab title="Filtering Options">
    * **By Application**: Focus on specific app packages
    * **By Tag**: Filter using log tags and categories
    * **By Time Range**: View logs within specific periods
    * **By Keyword**: Search for specific terms or patterns
    * **By PID/TID**: Track specific process or thread logs
  </Tab>

  <Tab title="Export Formats">
    * **Plain Text**: Simple log format for quick review
    * **JSON**: Structured format for automated analysis
    * **CSV**: Spreadsheet-compatible for reporting
    * **HTML**: Formatted view with syntax highlighting
  </Tab>
</Tabs>

**Advanced Features:**

* Real-time streaming with minimal latency
* Color-coded severity levels
* Regular expression pattern matching
* Log persistence across sessions
* Automatic log rotation and archival

### ADB Connectivity

#### Professional Development Bridge

Connect to cloud devices as if they were physically connected to your workstation:

<Steps>
  <Step title="Generate Connection">
    Click **Connect with ADB** to generate unique connection credentials
  </Step>

  <Step title="Configure Local ADB">
    ```bash
    adb connect device-id.nativebridge.io:5555
    ```
  </Step>

  <Step title="Authenticate">
    Enter the provided authentication token when prompted
  </Step>

  <Step title="Start Development">
    Use all standard ADB commands as with a local device
  </Step>
</Steps>

<Info>
  **Pro Tip**: Save frequently used devices as environment variables for quick reconnection:

  ```bash
  export NATIVE_BRIDGE_DEVICE="device-id.nativebridge.io:5555"
  adb connect $NATIVE_BRIDGE_DEVICE
  ```
</Info>

#### Supported ADB Operations

<CardGroup cols={3}>
  <Card title="Development" icon="code">
    * Install/uninstall apps
    * Deploy debug builds
    * Run instrumentation tests
    * Profile performance
  </Card>

  <Card title="Debugging" icon="bug">
    * Attach debuggers
    * Inspect databases
    * Monitor network traffic
    * Capture heap dumps
  </Card>

  <Card title="Automation" icon="robot">
    * Execute UI tests
    * Record/replay sessions
    * Capture screenshots
    * Generate bug reports
  </Card>
</CardGroup>

## Advanced Debugging Workflows

### Performance Profiling

<AccordionGroup>
  <Accordion title="CPU Profiling">
    Monitor CPU usage and identify performance bottlenecks:

    * Method-level profiling
    * Thread activity analysis
    * Call stack visualization
    * Flame graph generation
  </Accordion>

  <Accordion title="Memory Analysis">
    Track memory allocation and detect leaks:

    * Heap dump analysis
    * Allocation tracking
    * Reference chain inspection
    * Memory pressure simulation
  </Accordion>

  <Accordion title="Network Monitoring">
    Analyze network traffic and API calls:

    * Request/response inspection
    * Bandwidth usage tracking
    * Latency measurements
    * SSL/TLS debugging
  </Accordion>

  <Accordion title="Graphics Debugging">
    Optimize rendering and UI performance:

    * Frame rate monitoring
    * GPU usage analysis
    * Overdraw detection
    * Layout hierarchy inspection
  </Accordion>
</AccordionGroup>

## Integration Capabilities

### CI/CD Pipeline Integration

Incorporate debugging tools into automated workflows:

```yaml
# Example GitHub Actions Integration
- name: Debug Failed Tests
  if: failure()
  run: |
    native-bridge debug \
      --session-id ${{ env.SESSION_ID }} \
      --capture-logs \
      --screenshot \
      --heap-dump
```

### IDE Plugins

The debugging tools integrate with popular development environments. Please check the main platform documentation for current integration options.

## Best Practices

### Debugging Strategy

<Note>
  **Recommended Workflow**: Start with high-level logs, then progressively dive deeper using specialized tools as you narrow down the issue.
</Note>

1. **Initial Triage**: Review system logs for obvious errors
2. **Reproduce Issue**: Use session recording to capture the problem
3. **Deep Analysis**: Employ specific tools based on issue type
4. **Root Cause**: Use shell and file system access for investigation
5. **Verification**: Confirm fix using automated tests

### Security Guidelines

* Always use secure connections for ADB access
* Rotate authentication tokens regularly
* Limit debug access to development environments
* Sanitize logs before sharing externally
* Follow data protection regulations for user data

## Troubleshooting

| Issue                      | Solution                                         |
| -------------------------- | ------------------------------------------------ |
| ADB connection timeout     | Check firewall settings and authentication token |
| File upload failures       | Verify file size limits and storage quota        |
| Shell access denied        | Confirm subscription tier and permissions        |
| Log streaming interruption | Check network stability and reconnect            |
| File system not loading    | Clear browser cache and reload session           |

## Related Resources

For additional documentation and support resources, please check the main platform documentation or contact your system administrator.


# Embedding Apps
Source: https://docs.nativebridge.io/platform/app-management/embedding-apps

Embed your mobile apps directly into websites, documentation, and products using iframes

# Embedding Apps

Embed NativeBridge virtual devices directly into your own websites and products using iframes. Perfect for product demos, documentation, support portals, and interactive showcases.

## Finding Your Embed Link

Get your embed link in just a few clicks:

<Steps>
  <Step title="Navigate to Your Apps">
    Go to your [Apps Dashboard](https://nativebridge.io/dashboard/apps) or [App Builds](/platform/app-management/app-dashboard#app-builds-page) page
  </Step>

  <Step title="Click Share">
    Select the **Share** button under the app or build you want to embed
  </Step>

  <Step title="Copy Embed Link">
    Choose "Embed" from the share options to get your iframe-ready link
  </Step>
</Steps>

<Tip>
  Test parameters on your [App Page](/platform/app-management/running-and-testing-apps) first, then switch the URL from `/app/` to `/embed/` for iframe usage.
</Tip>

## Basic Embedding

Add your app to any website with a simple iframe:

```html
<iframe
  src="https://nativebridge.io/embed/{appId}?theme=light"
  width="400px"
  height="642px"
  title="Your App Name - Powered By NativeBridge"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  allowfullscreen>
</iframe>
```

### Live Example

Here's a real embedded app using NativeBridge:

```html
<iframe
  src="https://nativebridge.io/embed/VpJE?theme=light"
  width="400px"
  height="642px"
  title="Your Mobile App - Powered By NativeBridge"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  allowfullscreen>
</iframe>
```

## Embedding Options

<Note>Advanced Embedding options are only available with Starter, Growth and Custom plans. </Note>

### Responsive Design

Make your embedded app responsive to different screen sizes:

```html
<div style="position: relative; padding-bottom: 160.5%; height: 0;">
  <iframe
    src="https://nativebridge.io/embed/{appId}?theme=light"
    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"
    title="Your App Name - Powered By NativeBridge"
    frameborder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
    referrerpolicy="strict-origin-when-cross-origin"
    allowfullscreen>
  </iframe>
</div>
```

### Custom Device Frame

Add device frames for a more realistic appearance:

```html
<iframe
  src="https://nativebridge.io/embed/{appId}?device=iphone14pro&deviceColor=black&theme=light"
  width="430px"
  height="932px"
  title="Your App Name - Powered By NativeBridge"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  allowfullscreen>
</iframe>
```

### Autoplay Demo

Start your app automatically when the page loads:

```html
<iframe
  src="https://nativebridge.io/embed/{appId}?autoplay=true&launchUrl=home&theme=light"
  width="400px"
  height="642px"
  title="Your App Name - Powered By NativeBridge"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  allowfullscreen>
</iframe>
```

## Advanced Configurations

### With Query Parameters

Customize the embedded experience with query parameters:

```html
<iframe
  src="https://nativebridge.io/embed/{appId}?device=pixel7&osVersion=13&scale=75&centered=true&theme=light"
  width="500px"
  height="800px"
  title="Your App Name - Powered By NativeBridge"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  allowfullscreen>
</iframe>
```

### Popular Parameters for Embedding

| Parameter      | Description                 | Example             |
| -------------- | --------------------------- | ------------------- |
| `theme`        | Set light or dark theme     | `theme=light`       |
| `device`       | Set specific device model   | `device=iphone15`   |
| `osVersion`    | Choose OS version           | `osVersion=17.0`    |
| `scale`        | Adjust device size (25-100) | `scale=75`          |
| `centered`     | Center device in frame      | `centered=true`     |
| `deviceColor`  | Device frame color          | `deviceColor=white` |
| `hideControls` | Hide device controls        | `hideControls=true` |
| `language`     | Set device language         | `language=es`       |
| `autoplay`     | Start app automatically     | `autoplay=true`     |

## Use Cases

<CardGroup cols={2}>
  <Card title="Product Demos" icon="presentation">
    Embed interactive demos on your landing page to showcase features without downloads
  </Card>

  <Card title="Documentation" icon="book">
    Add live app examples directly in your docs for hands-on learning
  </Card>

  <Card title="Support Portal" icon="headset">
    Let customers reproduce issues in an embedded app for better support
  </Card>

  <Card title="Marketing Sites" icon="bullhorn">
    Create engaging product tours with embedded interactive experiences
  </Card>

  <Card title="Training Materials" icon="graduation-cap">
    Include live app instances in training content for practical learning
  </Card>

  <Card title="Blog Posts" icon="newspaper">
    Enhance articles with embedded app demos for better engagement
  </Card>
</CardGroup>

## Embedding in Different Platforms

### WordPress

Add to your WordPress site using the Custom HTML block:

```html
<!-- Add this to a Custom HTML block -->
<div class="nativebridge-embed">
  <iframe
    src="https://nativebridge.io/embed/{appId}?theme=light"
    width="400px"
    height="642px"
    title="Your App Name - Powered By NativeBridge"
    frameborder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
    referrerpolicy="strict-origin-when-cross-origin"
    allowfullscreen>
  </iframe>
</div>
```

### React

Embed in your React application:

```jsx
function AppDemo() {
  return (
    <iframe
      src="https://nativebridge.io/embed/{appId}?theme=light"
      width="400"
      height="642"
      title="Your App Name - Powered By NativeBridge"
      frameBorder="0"
      allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
      referrerPolicy="strict-origin-when-cross-origin"
      allowFullScreen
    />
  );
}
```

## Security & Permissions

### Content Security Policy

If your site uses CSP headers, add NativeBridge to your allowed frame sources:

```
Content-Security-Policy: frame-src https://nativebridge.io https://*.nativebridge.io;
```

### Sandbox Attributes

For additional security, you can add sandbox attributes (note: this may limit some functionality):

```html
<iframe
  src="https://nativebridge.io/embed/{appId}?theme=light"
  width="400px"
  height="642px"
  title="Your App Name - Powered By NativeBridge"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-modals"
  allowfullscreen>
</iframe>
```

## Best Practices

<Tabs>
  <Tab title="Performance">
    * **Lazy Load**: Load iframes only when visible
    * **Optimize Size**: Use appropriate dimensions for your use case
    * **Cache**: Leverage browser caching for repeat visitors
    * **CDN**: Ensure your page uses a CDN for faster loading
  </Tab>

  <Tab title="User Experience">
    * **Loading States**: Show a placeholder while iframe loads
    * **Responsive**: Ensure embeds work on all screen sizes
    * **Context**: Provide instructions or context around the embed
    * **Fallback**: Include a fallback link if iframe fails
  </Tab>

  <Tab title="Accessibility">
    * **Title**: Always include a descriptive title attribute
    * **Alternative**: Provide text alternatives for screen readers
    * **Keyboard**: Ensure keyboard navigation works properly
    * **Focus**: Manage focus states appropriately
  </Tab>
</Tabs>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Embed not loading">
    * Check if your embed URL is correct
    * Verify app permissions allow public embedding
    * Ensure no browser extensions are blocking iframes
    * Check browser console for CSP errors
  </Accordion>

  <Accordion title="Display issues">
    * Verify iframe dimensions match device size
    * Check if scale parameter is set appropriately
    * Ensure parent container has sufficient space
    * Test in different browsers
  </Accordion>

  <Accordion title="Performance problems">
    * Implement lazy loading for multiple embeds
    * Reduce number of embeds per page
    * Use smaller device scale when possible
    * Enable browser caching
  </Accordion>

  <Accordion title="Interaction limitations">
    * Some features may require full App Page access
    * Check if permissions are properly configured
    * Verify query parameters are correctly formatted
    * Test on actual App Page first
  </Accordion>
</AccordionGroup>

## API Integration

Control embedded apps programmatically:

```javascript
// Dynamically create and configure embedded app
function embedApp(containerId, appId, options = {}) {
  const container = document.getElementById(containerId);
  const iframe = document.createElement('iframe');

  // Build URL with parameters
  const params = new URLSearchParams(options);
  iframe.src = `https://nativebridge.io/embed/${appId}?${params}`;

  // Set iframe attributes
  iframe.width = options.width || '400';
  iframe.height = options.height || '642';
  iframe.title = options.title || 'App Demo - Powered By NativeBridge';
  iframe.frameBorder = '0';
  iframe.allow = 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share';
  iframe.referrerPolicy = 'strict-origin-when-cross-origin';
  iframe.allowFullscreen = true;

  container.appendChild(iframe);
}

// Usage
embedApp('demo-container', 'VpJE', {
  theme: 'light',
  device: 'iphone14pro',
  scale: 75,
  centered: true,
  autoplay: true,
  title: 'Your Mobile App - Powered By NativeBridge'
});
```

## Next Steps

<CardGroup cols={2}>
  <Card title="App Permissions" icon="lock" href="/platform/app-management/permissions">
    Configure who can embed your apps
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference">
    Automate app management and embedding
  </Card>
</CardGroup>


# App Permissions
Source: https://docs.nativebridge.io/platform/app-management/permissions

Control who can access your app and what features they can use

# App Permissions

## Who Can Run Your App

Control access to your app through different sharing methods and permission levels.

### Magic Link Access

When you share your app via magic link, you have control over who can access it:

```
https://nativebridge.io/app/{appId}
```

By default, anyone with the magic link can run your app. This makes it easy to share with stakeholders, clients, and testers without requiring them to create accounts.

### Authenticated Access

For apps containing sensitive data, you can require users to be authenticated and linked to your organization before they can access the App Page.

## Permission Levels

NativeBridge offers flexible permission management at two levels:

<Note>Advanced permissions are only available for Starter, Growth and Custom plans</Note>

### Organization-Level Permissions

Set default permissions that apply to all apps in your organization:

<Steps>
  <Step title="Navigate to Organization Settings">
    Go to [Organization → Session Defaults](https://nativebridge.io/organization/session-defaults)
  </Step>

  <Step title="Configure Default Permissions">
    Set your preferred default permissions for all apps
  </Step>

  <Step title="Save Changes">
    These settings will apply to all new apps and existing apps without custom permissions
  </Step>
</Steps>

### App-Level Permissions

Override organization defaults with app-specific permissions:

<Warning>
  App-level permissions will override organization defaults. We recommend using organization-level permissions for consistency unless you need specific exceptions.
</Warning>

<Steps>
  <Step title="Select Your App">
    Navigate to your [Dashboard](https://nativebridge.io/dashboard) and select your app
  </Step>

  <Step title="Choose Build">
    Select the specific build you want to configure permissions for
  </Step>

  <Step title="Configure Permissions">
    Go to **Settings → App Permissions** and adjust as needed
  </Step>
</Steps>

<Info>
  App permissions can also be configured when uploading via our API. See the [API Reference](/api-reference) for details.
</Info>

## Available Permissions

Configure these permissions to control what features are available when someone accesses your app:

| Permission                | Description                                                 | Default         |
| ------------------------- | ----------------------------------------------------------- | --------------- |
| **run**                   | Allow running your application                              | ✅ Enabled       |
| **networkProxy**          | Specify a custom network proxy when running the app         | ❌ Auth Required |
| **networkIntercept**      | Use NativeBridge's intercepting proxy for network debugging | ❌ Auth Required |
| **debugLog**              | View app's console output (NSLog/Logger or Logcat)          | ❌ Auth Required |
| **adbConnect**            | Connect ADB for Android debugging                           | ❌ Auth Required |
| **androidPackageManager** | Install additional APKs during app session                  | ❌ Auth Required |
| **deviceControl**         | Access device controls (rotation, location, etc.)           | ✅ Enabled       |
| **mediaUpload**           | Upload images/videos to the device                          | ✅ Enabled       |
| **screenshot**            | Take screenshots of the app                                 | ✅ Enabled       |

## Permission Scenarios

### Public Demo

For public demos and marketing:

* **run**: Public
* **screenshot**: Public
* **deviceControl**: Public
* All debugging features: Authenticated

### Internal Testing

For QA and development teams:

* All permissions: Authenticated
* Requires team members to sign in

### Client Review

For sharing with clients:

* **run**: Public
* **screenshot**: Public
* **deviceControl**: Public
* Technical features: Authenticated

### Beta Testing

For beta testers:

* **run**: Public with expiring links
* **screenshot**: Public
* **debugLog**: Public (for bug reports)
* Admin features: Authenticated

## Security Best Practices

<Cards>
  <Card title="Use Expiring Links" icon="clock">
    Set expiration dates on magic links for time-limited access
  </Card>

  <Card title="Require Authentication" icon="lock">
    Enable authentication for apps with sensitive data
  </Card>

  <Card title="Limit Debug Access" icon="shield">
    Keep debugging features restricted to authenticated users
  </Card>

  <Card title="Monitor Usage" icon="chart-line">
    Track who accesses your apps and when
  </Card>
</Cards>

## Managing Access

### Revoking Access

To revoke access to a shared app:

1. **Delete the magic link** - Removes public access immediately
2. **Update permissions** - Change to authenticated-only access
3. **Upload new build** - Previous build links become invalid

### Tracking Usage

Monitor app access through:

* Usage analytics dashboard
* Access logs
* Session recordings (with permission)

## API Configuration

Configure permissions programmatically when uploading apps:

```javascript
// Upload with custom permissions
const response = await fetch('https://api.nativebridge.dev/v1/apps', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    file: appFile,
    permissions: {
      run: 'public',
      debugLog: 'authenticated',
      networkIntercept: 'authenticated',
      adbConnect: 'authenticated'
    }
  })
});
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Upload Your App" icon="upload" href="/platform/app-management/uploading-apps/uploading-apps">
    Start uploading and setting permissions
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference">
    Automate permission management
  </Card>
</CardGroup>


# Running & Testing Apps
Source: https://docs.nativebridge.io/platform/app-management/running-and-testing-apps

Run, test, and debug your mobile apps instantly on real devices in the cloud via magic links

# Running Apps

## The App Page: Your Magic Link Destination

When anyone clicks a **magic link** you've shared, they're instantly taken to the **App Page** - NativeBridge's powerful, browser-based testing environment. No downloads, no installations, no setup - just immediate access to your app running on real devices in the cloud.

<Note>
  **What is the App Page?**
  The App Page is the interactive testing interface that opens when someone clicks your magic link. It's where your app comes to life in the browser, complete with device controls, debugging tools, and testing features.
</Note>

## Features Available on the App Page

When stakeholders access your app via magic link, they get instant access to:

### Device & OS Selection

* Wide range of supported devices and OS versions
* Switch between different device models in real-time
* Test on the latest iOS and Android versions

### Debugging Tools

Advanced debugging capabilities to streamline your development:

* **UI Automation (AppRecorder)** - Record and replay user interactions
* **Network Traffic Monitor** - Inspect all network requests and responses
* **Debug Logs** - View console and system logs in real-time
* **ADB Tunnel** - Direct ADB access (Android only)

### Device Toolbar

Complete control over device features and settings:

<Tabs>
  <Tab title="System Controls">
    * Home/Lock buttons
    * Rotate device orientation
    * Shake device gesture
    * Toggle soft keyboard
  </Tab>

  <Tab title="Device Settings">
    * Light/Dark mode toggle
    * Change GPS location
    * Switch between languages
    * Adjust font scale
  </Tab>

  <Tab title="Testing Features">
    * Biometric authentication
    * Add media files
    * Take screenshots
    * Screen recording
  </Tab>
</Tabs>

## Accessing the App Page

The App Page is what your users see when they click on a magic link. There are several ways to access it:

### Via Magic Link (Primary Method)

When you upload an app and generate a magic link, anyone with the link can instantly access the App Page:

```
https://nativebridge.io/app/{appId}
```

<Info>
  **This is what happens when someone clicks your magic link:**

  1. They're taken directly to the App Page in their browser
  2. The app loads instantly on a cloud device
  3. They can start testing immediately - no setup required
</Info>

### Direct Access Methods

#### Latest Build

The magic link defaults to the latest version of the app when opened. You can access the most recent build directly:

```
https://nativebridge.io/app/{appId}
```

<Steps>
  <Step title="Navigate to Apps Dashboard">
    Go to your [Apps Dashboard](https://nativebridge.io/dashboard/apps)
  </Step>

  <Step title="Select Your App">
    Click the **Play** button on the app you want to run
  </Step>

  <Step title="App Page Opens">
    The App Page launches with your app running on the selected device
  </Step>
</Steps>

#### Specific Build

Access a specific build version using the version or via the drop down on the magic link page:

```
https://nativebridge.io/app/{appId}?version={appVersion}
```

Example

```
https://nativebridge.io/app/aBcD?version=3.0
```

To access specific builds through the dashboard:

1. Navigate to your [Apps page](https://nativebridge.io/dashboard/apps)
2. Select the app containing your desired build
3. Browse and select from available builds in the builds history
4. The App Page opens with that specific build

## Creating & Sharing Magic Links

Magic links are the primary way to share your app. When recipients click the link, they're taken directly to the App Page where your app runs instantly.

<CardGroup cols={2}>
  <Card title="Generate Link" icon="link">
    Upload your app and instantly get a magic link that opens the App Page
  </Card>

  <Card title="Set Permissions" icon="shield">
    Control what features are available on the App Page for different users
  </Card>

  <Card title="Track Usage" icon="chart-bar">
    Monitor how users interact with your app through the App Page
  </Card>

  <Card title="Expire Links" icon="clock">
    Set time limits for how long the App Page remains accessible
  </Card>
</CardGroup>

<Warning>
  **Important:** Anyone with the magic link can access the App Page and test your app. Share links only with intended recipients and use expiration dates for sensitive apps.
</Warning>

## Testing Workflows on the App Page

When you or your stakeholders access the App Page via magic link, several testing workflows are available:

### Manual Testing

Perfect for exploratory testing and bug reproduction directly on the App Page:

1. Click the magic link to open the App Page
2. Select your target device and OS from the toolbar
3. Interact with your app as a real user would
4. Use the built-in debugging tools to identify issues
5. Share findings with your team instantly

### Stakeholder Review

The App Page is ideal for getting feedback without technical setup:

1. Generate a magic link after uploading your app
2. Share the link with stakeholders via email or chat
3. They click the link and the App Page opens immediately
4. They can test the app and provide feedback in real-time
5. No app stores, no downloads, no provisioning profiles needed

### Automated Testing

While users interact with the App Page manually, you can also:

* Run Appium tests against the same environment
* Execute Maestro flows
* Perform regression testing
* Generate test reports

### Cross-Platform Testing

The App Page allows instant switching between configurations:

* Different OS versions
* Various screen sizes
* Multiple device manufacturers
* Network conditions

All accessible from the same magic link!

## Next Steps

<CardGroup cols={2}>
  <Card title="Debugging Features" icon="bug" href="/platform/app-management/debugging-tools">
    Learn about advanced debugging tools
  </Card>

  <Card title="Test Automation" icon="robot" href="/testing/test-automation">
    Set up automated testing workflows
  </Card>

  <Card title="API Integration" icon="code" href="/api-reference">
    Integrate with your development workflow
  </Card>
</CardGroup>


# Android
Source: https://docs.nativebridge.io/platform/app-management/uploading-apps/android

Upload and test your Android applications on real devices in the cloud

# Android

## Finding your APK file

### With Android Studio

Select **Build** → **Build APK(s)** → **Build APK(s)** or **Build** → **Generate Signed APK** (and follow the prompts)

<Steps>
  <Step title="Build Your APK">
    Navigate to the Build menu in Android Studio and select your preferred build option
  </Step>

  <Step title="Locate Your APK">
    Once the build is complete, you can locate the `.apk` file by selecting `locate` in the dialog that appears, or by navigating to:

    ```
    {project_name}/{app_module_name}/build/outputs/apk/
    ```
  </Step>
</Steps>

### With Gradle

Generate your build with `gradle` by running the `assemble` command for your preferred app build variant (e.g. `debug` variant):

```bash
./gradlew assembleDebug
```

Once the build is complete, you can locate the `.apk` file by navigating to:

```
{project_name}/{app_module_name}/build/outputs/apk/
```

## Converting AAB to APK

NativeBridge currently only supports `apk` files for Android. If you have an `aab` (Android App Bundle) file, you'll need to convert it to an `apk` using Google's [`bundletool`](https://developer.android.com/tools/bundletool).

### Generate Universal APKs

```bash
bundletool build-apks --bundle=/<your_app>/{aab_name}.aab \
    --output=/{your_app}/{app_name}.apks \
    --mode=universal
```

### Extract Single APK file

```bash
unzip -p /{your_app}/{app_name}.apks universal.apk > /{your_app}/{app_name}.apk
```

## Troubleshooting

If you are having trouble running your uploaded Android app in NativeBridge, we recommend testing the same APK on the standard Google-provided Android emulator locally over ADB.

Once your emulator is launched and available via `adb devices`, you can install it using:

```bash
adb install -r {your_app}.apk
```

Or simply drag the `apk` file into the emulator window.

<Info>
  Check our [Knowledge Base](https://support.nativebridge.dev/) for frequently asked questions and solutions.
</Info>

## Next Steps

<CardGroup cols={2}>
  <Card title="Upload Your App" icon="upload" href="/platform/app-management/uploading-apps/uploading-apps">
    Ready to upload? Head to our upload page
  </Card>

  <Card title="iOS Build" icon="apple" href="/platform/app-management/uploading-apps/ios">
    Learn about iOS app preparation
  </Card>
</CardGroup>


# iOS
Source: https://docs.nativebridge.io/platform/app-management/uploading-apps/ios

Upload and test your iOS applications on real iPhone and iPad devices in the cloud

# iOS

NativeBridge currently only supports iOS Simulator builds (**.app**). A simulator build can be run in the iOS Simulator with Xcode. AppStore distribution device builds (**.ipa**) are also supported.

<Info>
  For optimal performance and compatibility, we recommend uploading ARM simulator builds of your iOS app.
</Info>

## Finding your .app file

### With Xcode

The easiest way to get the iOS Simulator build is to run and build your application in Xcode while targeting an iOS Simulator.

<Steps>
  <Step title="Select iOS Simulator">
    Build and run your application from Xcode while targeting a simulator device from the device dropdown.
  </Step>

  <Step title="Build Your App">
    Once the build is complete and the app is running in the simulator, you can locate the `.app` file by navigating to **Product** → **Show Build Folder in Finder** → **Products/Debug-iphonesimulator**
  </Step>
</Steps>

### With Xcode Command Line Tools

You can also generate the iOS Simulator build of your app by building it directly via the command line using `xcodebuild`.

#### With .xcodeproj

```bash
xcodebuild -project '{project_name}.xcodeproj' \
 -scheme '{scheme_name}' \
 -sdk iphonesimulator \
 -configuration Debug
```

#### With .xcworkspace

```bash
xcodebuild -workspace '{your_workspace_name}.xcworkspace' \
 -scheme '{scheme_name}' \
 -sdk iphonesimulator \
 -configuration Debug
```

The `app` file can then be found under:

```
build/Debug-iphonesimulator/
```

## Compress your .app file

Once you have located your `.app` file, NativeBridge requires it to be in a compressed `zip` or `tar.gz` file:

```bash
zip -r {app_name}.zip {app_name}.app
```

## Troubleshooting

If you are having trouble running your uploaded iOS app in NativeBridge, we recommend trying to run the same app on a simulator provided by Apple in Xcode.

Once your simulator is launched, you can simply drag the `.app` file into the simulator window to test it locally first.

Also check our [Knowledge Base](https://support.nativebridge.dev/) for frequently asked questions and solutions.

## Next Steps

<CardGroup cols={2}>
  <Card title="Upload Your App" icon="upload" href="/platform/app-management/uploading-apps/uploading-apps">
    Ready to upload? Head to our upload page
  </Card>

  <Card title="Android Build" icon="android" href="/platform/app-management/uploading-apps/android">
    Learn about Android app preparation
  </Card>
</CardGroup>


# Uploading Apps
Source: https://docs.nativebridge.io/platform/app-management/uploading-apps/uploading-apps

Get your mobile app onto NativeBridge in just minutes - ready to use across all major devices and operating systems.

# Uploading Apps

## Preparing your Build

<CardGroup cols={2}>
  <Card title="Android" icon="android" href="/platform/app-management/uploading-apps/android">
    Learn how to prepare your Android APK for upload
  </Card>

  <Card title="iOS" icon="apple" href="/platform/app-management/uploading-apps/ios">
    Learn how to prepare your iOS app for upload
  </Card>
</CardGroup>

<Info>
  We support cross-platform apps made in Flutter, Xamarin, React-Native, Kotlin Multiplatform and others which generate `.app` or `.apk` builds.

  For common issues and troubleshooting, visit our [Knowledge base](https://support.nativebridge.dev/uploading-and-installing-apps).
</Info>

## Upload your App

### With Upload Page

To upload your application via a web browser use our 'Upload' dialog on the landing page or on the [App Section](https://nativebridge.io/dashboard/apps)

#### Update existing Apps

To update an existing app, follow the same steps as uploading a new app via the [Upload](https://nativebridge.io/upload) dialog. The latest build will automatically be associated with your app.

To view all builds for an app, select the app and go to the App Builds Page.

<Warning>
  In some instances, you might want to explicitly update a particular app build. To do so, follow these steps:

  1. Go to the [Apps Dashboard](https://nativebridge.io/dashboard/apps)
  2. **Select the app**
  3. Click on 'Upload a new version'
  4. Done
</Warning>

### With CI/CD and Third-Party Integrations

NativeBridge integrates with several popular CI/CD tools and other third-party services, allowing you to:

* **Ensure Your App is Always Up-To-Date:**
  Automatically upload the latest builds with one of our many CI/CD integrations.
* **Eliminate Manual Processes:**
  Automate rolling out of updated apps or specific builds, saving time and effort.
* **Improve User and Development Workflows:**
  Integrate with tools such as Storybook Native and Expo to improve user and developer experiences.
* **Run Tests on Pull Requests:**
  Automatically upload and test builds on Pull Requests for efficient quality assurance.

Available integrations include:

<CardGroup cols={3}>
  <Card title="GitHub Actions" icon="github" href="https://github.com/nativebridge/github-action-nativebridge">
    Automate your workflow with GitHub Actions
  </Card>

  <Card title="GitLab" icon="gitlab" href="https://docs.nativebridge.dev/guides/gitlab-integration">
    Create review apps with GitLab CI/CD
  </Card>

  <Card title="Bitrise" icon="code-branch" href="https://bitrise.io/integrations/steps/nativebridge-deploy">
    Deploy with Bitrise step
  </Card>

  <Card title="Expo" icon="mobile" href="https://expo.dev/">
    Seamless integration with Expo
  </Card>

  <Card title="Fastlane" icon="rocket" href="https://docs.fastlane.tools/actions/nativebridge/">
    Automate with Fastlane
  </Card>

  <Card title="Storybook Native" icon="book" href="https://github.com/storybookjs/native">
    Component-driven development
  </Card>
</CardGroup>

<Info>
  If there is a 3rd party integration that you think should be on this list, please let us [know](mailto:contact@autoflowapp.com)!
</Info>

### With REST API

NativeBridge also supports uploading your application programmatically by making use of our REST API:

<CardGroup cols={1}>
  <Card title="API Documentation" icon="plus" href="/api-reference">
    Check out detailed documentation here
  </Card>
</CardGroup>

<Note>
  The **latest build** refers to the most recent version of your app on Android, identified by the [versionCode](https://developer.android.com/studio/publish/versioning#versioningsettings), and on iOS, by the [CFBundleShortVersionString](https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundleshortversionstring) and [CFBundleVersion](https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundleversion).
</Note>


# Test & App Automation
Source: https://docs.nativebridge.io/testing/test-automation

Enterprise-grade mobile application testing and automation platform supporting Appium, Maestro, and custom frameworks for comprehensive quality assurance

## Overview

NativeBridge Test Automation provides a powerful, cloud-based platform for automating mobile application testing across iOS and Android devices. With support for industry-standard frameworks like Appium and Maestro, teams can execute comprehensive test suites, continuous integration workflows, and performance validations at scale.

<CardGroup cols={2}>
  <Card title="Appium Support" icon="robot">
    Full compatibility with Appium WebDriver protocol for cross-platform testing
  </Card>

  <Card title="Maestro Framework" icon="wand-magic-sparkles">
    Native support for Maestro's declarative testing approach
  </Card>

  <Card title="Cloud Devices" icon="cloud">
    Access to real devices in the cloud for authentic testing scenarios
  </Card>

  <Card title="CI/CD Integration" icon="infinity">
    Seamless integration with popular CI/CD pipelines
  </Card>
</CardGroup>

## Getting Started

### Accessing the Automation Platform

<Steps>
  <Step title="Navigate to Your Profile">
    Click on the profile icon in the top-right corner of the interface
  </Step>

  <Step title="Select App Automation">
    Choose **App Automation** from the menu or navigate directly to [App Automation Section](https://nativebridge.io/dashboard/app-automation)
  </Step>

  <Step title="Choose Your Workspace">
    Select an existing workspace or create a new one for your automation projects
  </Step>
</Steps>

## Project Management

### Creating Projects

NativeBridge offers multiple methods to initialize your automation projects:

<Tabs>
  <Tab title="New Project">
    Start fresh with a structured project template:

    * Pre-configured directory structure
    * Sample test files for quick start
    * Framework-specific boilerplate code
    * Environment configuration templates
  </Tab>

  <Tab title="Import Folder">
    Upload existing test suites from your local environment:

    * Drag-and-drop folder upload
    * Automatic dependency detection
    * Configuration file recognition
    * Bulk file import with structure preservation
  </Tab>

  <Tab title="GitHub Integration">
    Connect directly to your repository:

    * OAuth-based authentication
    * Branch selection and management
    * Automatic sync with commits
    * Pull request integration
  </Tab>
</Tabs>

### IDE Environment

The integrated development environment provides a comprehensive workspace for test development:

<AccordionGroup>
  <Accordion title="Code Editor Features">
    * **Syntax Highlighting**: Language-specific highlighting for test scripts
    * **IntelliSense**: Auto-completion for framework methods and properties
    * **Error Detection**: Real-time syntax and logic error identification
    * **Code Formatting**: Automatic code formatting and linting
  </Accordion>

  <Accordion title="File Management">
    * **Project Explorer**: Hierarchical view of all project files
    * **Search & Replace**: Global search across all project files
    * **Version Control**: Built-in Git integration for tracking changes
    * **File Templates**: Quick creation of test files from templates
  </Accordion>

  <Accordion title="Testing Tools">
    * **Test Runner**: Execute tests directly from the editor
    * **Debugging**: Breakpoint support and step-through debugging
    * **Console Output**: Real-time test execution logs
    * **Result Viewer**: Interactive test result analysis
  </Accordion>
</AccordionGroup>

## Test Execution

### Execution Methods

<CardGroup cols={3}>
  <Card title="UI Execution" icon="play">
    Run tests directly from the web interface with visual feedback
  </Card>

  <Card title="API Triggers" icon="code">
    Programmatic execution via REST API for automation pipelines
  </Card>

  <Card title="Magic Links" icon="link">
    Shareable URLs for triggering specific test suites
  </Card>
</CardGroup>

### Running Tests via UI

#### Single Test Execution

1. Navigate to your project in the IDE
2. Select the desired spec file from the project explorer
3. Click the **Run** button (green play icon) in the toolbar
4. Configure device and environment settings in the modal
5. Monitor real-time execution progress

#### Batch Test Execution

<Note>
  **Multi-file Selection**: Hold `Ctrl/Cmd` while clicking to select multiple test files, or use `Shift+Click` for range selection. All selected tests will run sequentially or in parallel based on your configuration.
</Note>

### API-Based Execution

Integrate test execution into your CI/CD pipeline:

```bash
curl -X POST https://api.nativebridge.io/v1/tests/run \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "your-project-id",
    "testFiles": ["test1.spec.js", "test2.spec.js"],
    "device": "iPhone-14-Pro",
    "framework": "appium"
  }'
```

### Magic Links

Generate shareable execution links for non-technical stakeholders:

1. Configure your test suite in the UI
2. Click **Generate Magic Link**
3. Share the URL with team members
4. Recipients can trigger tests without platform access

## Supported Frameworks

### Appium Configuration

<Tabs>
  <Tab title="Capabilities">
    ```json
    {
      "platformName": "iOS",
      "platformVersion": "16.0",
      "deviceName": "iPhone 14 Pro",
      "app": "path/to/app.ipa",
      "automationName": "XCUITest",
      "noReset": true
    }
    ```
  </Tab>

  <Tab title="Sample Test">
    ```javascript
    describe('Login Test', () => {
      it('should login successfully', async () => {
        await driver.findElement(By.id('username')).sendKeys('user@example.com');
        await driver.findElement(By.id('password')).sendKeys('password123');
        await driver.findElement(By.id('loginButton')).click();

        const welcomeText = await driver.findElement(By.id('welcomeMessage')).getText();
        expect(welcomeText).toBe('Welcome back!');
      });
    });
    ```
  </Tab>
</Tabs>

### Maestro Configuration

<Tabs>
  <Tab title="Flow Definition">
    ```yaml
    appId: com.example.app
    ---
    - launchApp
    - tapOn: "Get Started"
    - inputText: "user@example.com"
    - tapOn: "Continue"
    - assertVisible: "Welcome Dashboard"
    ```
  </Tab>

  <Tab title="Advanced Flow">
    ```yaml
    appId: com.example.app
    env:
      USERNAME: test@example.com
      PASSWORD: ${PASSWORD}
    ---
    - launchApp:
        clearState: true
    - tapOn:
        id: "login_button"
    - inputText: ${USERNAME}
    - tapOn: "Next"
    - inputText: ${PASSWORD}
    - tapOn: "Sign In"
    - waitForAnimationToEnd
    - takeScreenshot: "login_success"
    ```
  </Tab>
</Tabs>

## Advanced Features

### Parallel Execution

Run multiple tests simultaneously across different devices:

<Info>
  **Performance Boost**: Parallel execution can reduce total test time by up to 80% compared to sequential runs. Configure parallelization in your project settings.
</Info>

### Test Data Management

<CardGroup cols={2}>
  <Card title="Environment Variables" icon="key">
    Secure storage and injection of sensitive test data
  </Card>

  <Card title="Data Files" icon="database">
    CSV, JSON, and Excel support for data-driven testing
  </Card>

  <Card title="Dynamic Generation" icon="shuffle">
    Built-in functions for generating test data on-the-fly
  </Card>

  <Card title="External APIs" icon="plug">
    Integration with external data sources and services
  </Card>
</CardGroup>

### Reporting & Analytics

#### Test Reports

* **Detailed Results**: Pass/fail status, execution time, error messages
* **Screenshots**: Automatic capture at failure points
* **Video Recording**: Full session recordings for debugging
* **Performance Metrics**: CPU, memory, and network usage

#### Analytics Dashboard

* **Trend Analysis**: Historical pass rates and execution times
* **Flaky Test Detection**: Identify unstable tests automatically
* **Coverage Metrics**: Track test coverage across features
* **Custom Dashboards**: Build personalized views with key metrics

## Best Practices

<AccordionGroup>
  <Accordion title="Test Organization">
    * Group related tests into suites
    * Use descriptive naming conventions
    * Implement page object patterns
    * Maintain separate configuration files
  </Accordion>

  <Accordion title="Performance Optimization">
    * Minimize unnecessary waits
    * Use efficient element locators
    * Implement smart retry logic
    * Cache reusable test data
  </Accordion>

  <Accordion title="Maintenance Strategy">
    * Regular review of test failures
    * Update locators proactively
    * Remove obsolete tests
    * Document test purposes clearly
  </Accordion>

  <Accordion title="CI/CD Integration">
    * Automate test triggers on commits
    * Set up quality gates
    * Configure notifications
    * Archive test artifacts
  </Accordion>
</AccordionGroup>

## Troubleshooting

### Common Issues

| Issue                     | Solution                                           |
| ------------------------- | -------------------------------------------------- |
| Tests timing out          | Increase wait times or check network connectivity  |
| Element not found         | Verify selector accuracy and page load status      |
| Session creation failed   | Check device availability and app compatibility    |
| Parallel execution errors | Reduce concurrency or increase resource allocation |

<Warning>
  **Resource Limits**: Be aware of your plan's concurrent execution limits. Exceeding these may result in queued tests or execution failures.
</Warning>

## API Reference

### Authentication

All API requests require authentication via Bearer token:

```bash
Authorization: Bearer YOUR_API_KEY
```

### Endpoints

* `POST /v1/tests/run` - Execute test suite
* `GET /v1/tests/{id}/status` - Check execution status
* `GET /v1/tests/{id}/results` - Retrieve test results
* `POST /v1/projects/create` - Create new project
* `PUT /v1/projects/{id}/update` - Update project configuration

## Related Resources

For additional documentation and support resources, please check the main platform documentation or contact your system administrator.