# Quick Start for Actor Creation (`apify/quick-start`) Actor

Contains a basic boilerplate of an Apify actor with Node.js source code and a custom Dockerfile. The purpose of this actor is to help you get started quickly to create your own actors.

- **URL**: https://apify.com/apify/quick-start.md
- **Developed by:** [Apify](https://apify.com/apify) (Apify)
- **Categories:** Developer tools, Open source
- **Features:** Full permissions
- **Stats:** 60 total users, 0 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 4.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

This is a simple Apify actor that serves as a basic boilerplate.
It has a Node.js source code, custom Dockerfile and it's hosted in a Git repository.
Feel free to copy this actor, modify it and use it in your own actors.

Are you missing anything? Something not clear? Please let us know at support@apify.com

To run the actor in your local environment, simply run the following commands:

```bash
npm install
npm run start
```

Alternatively, if you have [Apify CLI](https://apify.com/docs/cli) installed, you can start the actor by running:

```bash
apify run
```

In order to test the build of the Docker image, you can run:

```
docker build ./
```

On success, the command will print something like:

```
...
Removing intermediate container 22915a918e4c
Step 6/6 : CMD node main.js
 ---> Running in 7288f9a12cf0
 ---> 0d82ea8a648d
Removing intermediate container 7288f9a12cf0
Successfully built XYZ
```

After that you can run the built Docker image locally using:

```bash
docker run XYZ
```

Where `XYZ` is ID of the Docker image built in the previous step.

If there is any problem with the built image, you might try troubleshooting it
by starting the container in interactive mode using:

```
docker run -it XYZ /bin/bash
```

Note that this requires a base Docker image that contains bash or some other interactive shell.

### `.gitignore`

Specifies files and directories that shouldn't be included in the Git repository.

### `apify.json`

The file is used by [Apify CLI](https://apify.com/docs/cli)
and it contains information linking your local source code directory with the
actor on the Apify platform.
You only need this file if you want to run commands such as `apify run`
or `apify push`.

### `Dockerfile`

Contains instructions how to build a Docker image that will contain
all the code and configuration needed to run your actor.
For more information, see [Dockerfile reference](https://docs.docker.com/engine/reference/builder/).

### `INPUT_SCHEMA.json`

Defines schema for the actor input. It is used by the Apify platform
to automatically check the input for the actor and to generate
a user interface to help users of your actor to run it.
For more information, see [Input Schema documentation](https://apify.com/docs/actor/input-schema).

### `main.js`

The main Node.js source code of your actor.
It is referenced from the `scripts` section of the `package.json` file,
so that it can be started by running `npm start`.

### `package.json`

The file is used by NPM to maintain metadata about the Node.js source code,
such as the list of dependencies.
For details, see [NPM documentation](https://docs.npmjs.com/files/package.json).

### `README.md`

Contains a [Markdown](https://www.markdownguide.org/cheat-sheet)
documentation what your actor does and how to use it,
which is then displayed in the app or [library](https://apify.com/apify/quick-start).
It's always a good idea to write a good README.md, in a few months not even you
will remember all the details about the actor.

### `apify_storage`

This directory contains data from
[Apify SDK storages](https://sdk.apify.com/docs/guides/data-storage)
during local development, such as the key-value stores,
datasets and request queues.
Typically you don't want to have the `apify_storage` directory in Git repo,
but in this boilerplate we keep the `INPUT.json` file in Git
for documentation purposes.

When running the actor on the Apify platform, the actor is automatically assigned
a key-value store that is used to store actor's input, output or any other data.
The `apify_storage/key_value_stores/default` directory is used to emulate this store
during the local development of your actor.
The files in the directory represent the records in the key-value store: the name
of each file corresponds to its key and the content to the value.

For example, calling `Apify.getValue('INPUT')` will return the content
of the `apify_storage/key_value_stores/default/INPUT.json` file parsed as JSON. Similarly, calling
`Apify.setValue('OUTPUT', ...)` will write a file to `apify_storage/key_value_stores/default/OUTPUT.json`.

For more information, see the [Getting Started](https://sdk.apify.com/docs/guides/getting-started) tutorial
of the [Apify SDK](https://sdk.apify.com).

# Actor input Schema

## `message` (type: `string`):

Just enter your hello world message.

## Actor input object example

```json
{}
```

# 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("apify/quick-start").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("apify/quick-start").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 apify/quick-start --silent --output-dataset

```

## MCP server setup

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

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/ox5STG6XKWXSGdu7w/builds/8yI7JqCj1Ru9bnxL1/openapi.json