# ActorWebApp (`solutionssmart/actorwebapp`) Actor

Turn a compatible Apify Actor into a branded web app with a simple input form, run status, Dataset results, exports, and shareable Standby URL. Give customers and teammates an easier way to use your Actor without exposing your API token.

- **URL**: https://apify.com/solutionssmart/actorwebapp.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 web app runs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Actor Web App

Turn an Apify Actor into a shareable web app with a generated input form, run status, Dataset preview, exports, and output-file links. Actor Web App reads the target Actor's default-build input schema, groups supported fields into a clear form, starts the target run, and displays its default Dataset without exposing your Apify API token.

Use it when you want a friendly frontend for an Apify Actor without building and hosting a separate application. It works with crawlers, extractors, research tools, and other Actors that expose a compatible input schema.

### Why use Actor Web App

- Generates a web form from the target Actor's Apify input schema.
- Supports labels, help text, defaults, examples, selectors, numeric limits, sections, arrays, request lists, and other rich input types.
- Hides common Apify technical fields when you want a simpler end-user experience.
- Validates submitted input before starting the target Actor.
- Shows run progress, status, Dataset rows, JSON and CSV exports, and safe output files.
- Supports light, dark, and warm themes, a custom logo, and an accent color.
- Keeps Apify API calls and credentials on the server.

Use it with any compatible Apify Actor that you want to make easier for customers, teammates, or non-technical users to run.

#### Common use cases

- Turn a crawler into a branded website data collection tool.
- Give customers a simple interface for a lead generation or research Actor.
- Share a focused version of an internal Actor with a team.
- Add a results page and downloads without building a separate frontend.

### Get started

1. Deploy **Actor Web App** to your Apify account and enable **Standby mode**.
2. Set the target Actor ID in `username/actor-name` format.
3. Configure the Branding, Input display, and Output display groups.
4. Open the Standby URL and share it according to your access settings.

The target Actor must be available to the account running Actor Web App. Its default build must expose a compatible input schema. Results are read from the target run's default Dataset.

### Using the Standby URL

After the Actor has been built with Standby mode enabled:

1. Open the Actor's **Standby** tab in Apify Console.
2. Copy the displayed Standby URL.
3. Open the URL in a browser.
4. Complete the generated form and select the run button.
5. Wait for the target Actor to finish, then review the Dataset preview or download the available results.

The Standby URL is the shareable web app address. It is different from an individual run URL, which is intended for inspecting one specific run.

If the browser shows `api-token-missing`, the Actor's Standby access still requires authentication. Configure Standby access in Apify for the audience you intend to serve. For private or programmatic use, authenticate requests with an `Authorization: Bearer <token>` header. Apify also supports a `token` query parameter when a header cannot be used, but do not place a secret token in a public or shared browser URL. See the [Apify Standby documentation](https://docs.apify.com/actors/running/standby) for access and authentication details.

### Configuration

The Apify Console renders the configuration as grouped controls, so normal setup does not require editing JSON. The required field is `actorId`; all other fields are optional.

#### Complete example

```json
{
  "actorId": "solutionssmart/brand-dna",
  "title": "Brand DNA",
  "description": "Extract a structured brand profile from a website.",
  "branding": {
    "logoUrl": "https://example.com/logo.png",
    "accentColor": "#19724c",
    "theme": "light",
    "hideApifyTechnicalFields": true
  },
  "input": {
    "showAdvancedFields": false
  },
  "output": {
    "showTable": true,
    "allowCsv": true,
    "allowJson": true,
    "maxPreviewRows": 100
  }
}
```

Replace the example logo URL with an HTTPS image URL that you control. The logo appears in the generated app header. `accentColor` must be a six-digit hexadecimal color such as `#19724c`. The `theme` can be `light`, `dark`, or `warm`.

#### Branding examples

For a clean public app with no custom logo, use the default light theme:

```json
{
  "branding": {
    "accentColor": "#19724c",
    "theme": "light",
    "hideApifyTechnicalFields": true
  }
}
```

For a branded dark app, set the logo, accent color, and dark theme:

```json
{
  "branding": {
    "logoUrl": "https://example.com/brand-mark.png",
    "accentColor": "#d97706",
    "theme": "dark",
    "hideApifyTechnicalFields": true
  }
}
```

Set `hideApifyTechnicalFields` to `false` when advanced users need to see platform fields such as proxy, memory, or runtime options exposed by the target schema.

#### Input display examples

Use the compact form for most public apps:

```json
{
  "input": {
    "showAdvancedFields": false
  }
}
```

Show the full supported target schema when users need complete control:

```json
{
  "input": {
    "showAdvancedFields": true
  }
}
```

The generated form uses the target Actor's own labels, descriptions, defaults, selectors, arrays, request-list controls, and validation rules. Values entered by end users are sent to the target run and are not persisted in the browser by Actor Web App.

#### Output display examples

For a table with both downloads and a 100-row preview:

```json
{
  "output": {
    "showTable": true,
    "allowCsv": true,
    "allowJson": true,
    "maxPreviewRows": 100
  }
}
```

For a result page focused on downloads, hide the table and keep the exports:

```json
{
  "output": {
    "showTable": false,
    "allowCsv": true,
    "allowJson": true,
    "maxPreviewRows": 25
  }
}
```

`maxPreviewRows` accepts values from 1 to 500. JSON and CSV exports come from the target Dataset. HTML reports, JSON files, Markdown files, PDFs, and other supported files written by the target Actor are shown in the output-files section.

### Output

After a user submits the form, Actor Web App follows the target run until it finishes, fails, or is stopped. The results page shows the run status, a preview of the target Actor's default Dataset, downloads, and supported output files.

### Pricing

Actor Web App does not remove the costs of running the target Actor. Users may incur Apify platform usage costs and any charges defined by the target Actor. Standby mode may also incur platform costs while the app is active.

Actor Web App may charge for a successful web-app run when paid access is enabled. Users still pay the target Actor's own charges and any applicable platform usage costs. Review the pricing shown in Apify before starting a run, especially when the target Actor is long-running or expensive.

### Security and privacy

Apify API calls are made server-side with `APIFY_TOKEN`; the token is never sent to the browser. Target metadata is rendered as text, and user-entered values are sent only when a target run is started.

Configure Standby access in Apify to control who can open the app. Actor Web App does not add a separate authentication layer. Secret values entered into the generated form are not persisted in browser state by this Actor, but the target Actor may process them during its run according to its own behavior and policies.

### Limitations

- Supports the practical JSON Schema subset used by Apify input schema v1, not arbitrary composition such as `oneOf`, `$ref`, or conditional schemas.
- Reads the target Actor's default build, default Dataset, and filtered output files from the default Key-value store.
- Requires the configured account to be allowed to run the target Actor.
- Standby access, idle costs, target Actor permissions, and target Actor charges remain governed by Apify.
- Multi-Actor workflows, custom domains, quotas, payments, and white-labeling are not included.

### Frequently asked questions

#### Can I use a private target Actor?

Yes, if the account running Actor Web App has permission to run it and its default build exposes a supported input schema.

#### Does Actor Web App expose my Apify token?

No. The token remains in the Actor server process and is not returned to the browser.

#### Where do the results come from?

Results come from the target run's default Dataset. The app does not automatically combine multiple Actors or datasets.

#### Can I use the app from an API or automation workflow?

The app runs through Apify Standby and can be used with Apify API access, webhooks, schedules, and integrations according to your account and Actor configuration.

### Support

For a target-specific issue, check the target Actor's input schema, permissions, run log, and Dataset. For an Actor Web App issue, include the configured `actorId`, sanitized display settings, run ID, and relevant log messages when contacting the Actor maintainer. Do not include API tokens or other secrets in support requests.

# Actor input Schema

## `actorId` (type: `string`):

Actor in username/actor-name format.

## `title` (type: `string`):

Optional title shown to end users.

## `description` (type: `string`):

Optional short explanation of the app.

## `branding` (type: `object`):

Control the app identity, accent color, theme, and Apify field visibility.

## `input` (type: `object`):

Choose how much of the target Actor input schema is shown to end users.

## `output` (type: `object`):

Choose which result views and exports are available after a run.

## Actor input object example

```json
{
  "actorId": "solutionssmart/brand-dna",
  "branding": {
    "logoUrl": "",
    "accentColor": "#19724c",
    "theme": "light",
    "hideApifyTechnicalFields": true
  },
  "input": {
    "showAdvancedFields": true
  },
  "output": {
    "showTable": true,
    "allowCsv": true,
    "allowJson": true,
    "maxPreviewRows": 100
  }
}
```

# Actor output Schema

## `appManifest` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/actorwebapp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/actorwebapp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call solutionssmart/actorwebapp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solutionssmart/actorwebapp"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/SaTMLMPB21v0HAcvy/builds/BBGhKZXIBPmjIN6VN/openapi.json