Publish your Actor task

Actor tasks are shareable, pre-configured inputs for your Actors. Publishing a task creates a public landing page that shows what it does, what inputs to provide, and what output to expect. Published tasks also appear in your Actor's Example tasks tab, which helps users discover your Actor through search engines and AI agents. For monetized Actors, more discoverability means more paid runs.

You can publish up to 10 tasks per Actor, and up to 100 tasks across your account.

Prerequisites

Before you publish a task, make sure you have:

A published Actor that you own or maintain.
A saved task with a complete input configuration.
An input schema and at least one dataset schema view defined on the Actor.

If your Actor is missing an input schema or dataset schema, the Publishing tab shows what needs to be set up before you can publish.

What tasks to publish

Focus on tasks that represent a real use case someone would search for and that show your Actor solving a specific problem. Not every saved task needs a public landing page.

Focus on a real use case

The best tasks aim to solve a problem a user actually has. Instead of publishing a generic "default configuration" task, publish one that answers a question someone might type into a search engine or AI agent.

For example, if you maintain Google Maps, Amazon, and Yahoo Finance scraper Actors:

Generic task	Specific task
Google Maps business task	Analyze San Francisco business competitors with AI
Yahoo Finance test	Monitor stock prices on Yahoo Finance
Amazon scraper	Track Amazon product prices for market research

Each task focuses on a specific industry, location, or workflow. A user searching for "San Francisco business competitors" is more likely to land on a page with that exact framing.

Target search traffic and AI discovery

Each landing page shows up in Google search results. It also has a markdown (.md) version that AI agents can read directly.

Think of each task as a keyword-targeted landing page:

Location-specific tasks: "Scrape real estate listings in Austin" rather than "Scrape real estate listings"
Industry-specific tasks: "Monitor competitor pricing for electronics" rather than "Monitor competitor pricing"
Workflow-specific tasks: "Export LinkedIn company data to Google Sheets" rather than "Export LinkedIn data"

The more specific the task, the less competition it has in search results and the more relevant it is to the person who finds it.

Show the range of your Actor

If your Actor supports multiple use cases, publish a task for each one. A web scraping Actor might have tasks for lead generation, price monitoring, and content aggregation. Each task demonstrates a different capability and attracts a different audience.

Publish your tasks

Once your task runs reliably and produces the output you want users to see, publish it from Apify Console. The Publishing tab guides you through each requirement.

From your task's page in Apify Console, open the Publishing tab.
Complete the three required sections: Page details, Input, and Dataset schema. Optionally, add an FAQ.
Select Publish task.

The Publishing tab showing the Publish task button, three required sections, and the optional FAQ.

Page details

This section controls how your task appears on the landing page and in search results.

Title: the heading shown on the landing page. Required to publish.
Description: the summary shown under the heading on the landing page. Required to publish.
Slug: the URL path for your task's landing page (lowercase, hyphens, no spaces).
SEO title: the page title in search results. Falls back to the task title when empty.
SEO description: the meta description in search results. Falls back to the task description when empty.

Use the AI icon next to each field to generate its copy from your task configuration.

The preview on the right updates as you type:

Page preview: how the landing page will look to users.
Google preview: how the page will appear in search results.

Page details fields (title, description, slug, SEO title, SEO description) with live page and Google previews on the right.

Title format

Frame the title as the user's goal, not as a description of the Actor's mechanics. A good title combines an action, a target, and a qualifier.

Good examples:

Track competitors' store locations
Get a local B2B leads list
Verify business emails from Google Maps

Avoid titles like "Google Maps scraper - task 3" or "Test task" that describe the Actor instead of the user's goal.

Input

The Input section controls which fields from your task's input configuration appear on the landing page. Every input field is selected by default. Deselect any field that isn't relevant to this task's use case.

This control affects display only. The task itself always runs with the full input configuration, regardless of which fields are selected here.

Input section showing checkboxes to select which fields appear on the landing page.

Secret fields are protected automatically

All input fields with "isSecret": true in the Actor's input schema are automatically masked and never shown on the landing page. Before publishing, confirm sensitive fields are marked as secret.

Dataset schema

The Dataset schema section selects which view of the Actor's dataset is rendered on the landing page. Each view organizes the output fields differently. Pick the one that best matches the task's use case.

Dataset schema section with a dropdown to select which output view to display.

For more on configuring views, see Dataset schema.

FAQ

The optional FAQ section adds questions and answers to the landing page. The answers help people decide to run your task. They also give search engines and AI agents facts to quote in their answers.

Generate FAQ: writes questions and answers with AI, based on the task's title, description, and input, and on the Actor's README and dataset schema. If the task already has an FAQ, the AI uses it as a draft and replaces it after you confirm.
Add question: adds a question and answer that you write yourself.

Review and edit the generated questions and answers, then select Save. An FAQ can include up to 10 questions. Each question can be up to 120 characters, and each answer up to 250 characters.

FAQ section with the Generate FAQ button, two question-and-answer pairs with character counters, and the Add question button.

Write answers that stand alone

AI agents and search engines often quote a single answer without the question it answers. Name the task in each answer instead of starting with "It" or "Yes." Write "The Amazon price tracker task returns the product title, price, and image URL," not "Yes, it returns prices."

Aim for 3 to 8 questions, such as:

What does the output contain?
What input does the task need?
How do I run the task through the API or on a schedule?

Publish confirmation

When you select Publish task, a confirmation dialog reminds you that your runs and data stay private. Once published, anyone on Apify can duplicate and run your task with their own input.

A success dialog lets you share your task on social media. Use the View landing page button in the Publishing tab to preview it.

Unpublish a task

To remove a task's landing page, open the task's Publishing tab and select Unpublish task. Confirm to remove it.

Unpublishing removes the landing page, but your task and its configuration stay saved. Republish anytime.

To see which tasks are published, filter by Publish status in the Tasks list in the sidebar.

Publish tasks programmatically

Apify Console is the quickest way to publish your first task. If you maintain many tasks, you can do the same thing through the API, which lets you publish in bulk instead of completing the form for each task.

Creating a task never publishes it. There are three steps:

Create the task with its input.
Fill in the task's title and description, and its public display configuration (publicConfig).
Publish it by setting isPublic to true, or by calling publish() in the API clients.

Requirements

A task can only be published when all of the following hold:

The task's Actor is public.
The task has a title (3 to 63 characters) and a description (up to 400 characters). The landing page renders these.
publicConfig.inputSchemaFields names at least one field that exists in the task's input. These are the input values shown on the page.
publicConfig.datasetView is one of the view keys declared in the Actor's dataset schema. Set publicConfig.datasetName too if the Actor declares more than one dataset.
You have write access to both the task and its Actor.
The Actor has fewer than 10 published tasks.

publicConfig.seoTitle (up to 60 characters) and publicConfig.seoDescription (up to 160 characters) are optional. They appear in search results only and fall back to the task's title and description when empty. Search engines display only that much text, so they cut a longer title or 400-character description if you leave these fields empty.

publicConfig.faq is optional too. It holds up to 10 { "question": "...", "answer": "..." } objects, with questions up to 120 characters and answers up to 250 characters. Neither can be blank.

If any requirement is unmet, the request fails and none of the update is applied, so the task never ends up half-configured.

Publish with an AI agent

The Apify MCP server exposes task publishing as tools, so you can describe what you want in your AI client and let the agent do the work: create-actor-task, get-actor-task, update-actor-task, publish-actor-task, and unpublish-actor-task.

These tools are in the tasks category, which is not enabled by default. Include it in your connection URL:

https://mcp.apify.com?tools=actors,docs,tasks

The requirements above still apply. The agent fills in the display configuration with update-actor-task first, then publishes with publish-actor-task.

Publish with the API

Create the task with the Create Actor task endpoint, then configure and publish it with the Update Actor task endpoint:

PUT /v2/actor-tasks/{actorTaskId}
Content-Type: application/json

{
    "title": "Track competitors' store locations",
    "description": "Looks up each brand name you provide on Google Maps and collects its store addresses, opening hours, and coordinates. Use the results to compare competitor coverage in a city or region and to find gaps in your own network.",
    "isPublic": true,
    "publicConfig": {
        "seoDescription": "Get addresses and opening hours for any list of competitor brands.",
        "inputSchemaFields": ["searchStringsArray", "maxCrossedDistance"],
        "datasetView": "overview"
    }
}

The fields you send in publicConfig are merged into the stored configuration, so you only need to include what you are changing. To clear a field, set it to null. publicConfig.publishedAt is read-only: publish and unpublish by setting isPublic.

To unpublish, send isPublic: false. The display configuration is preserved, so you can republish later without re-entering it.

Publish with the CLI

The Apify CLI publishes and unpublishes an existing task by name, from version 1.9.0:

apify task publish my-task
apify task unpublish my-task

Pass username/my-task to target a task owned by someone else, provided you have write access to it and its Actor.

There is no dedicated command for the display configuration yet, so set it through the API with apify api. Unlike apify task publish, this passes the path straight to the API, which reads an unqualified value as a task ID. Use the username~task-name format so the task is found by name:

apify api PUT actor-tasks/username~my-task -d '{
    "publicConfig": {
        "inputSchemaFields": ["searchStringsArray"],
        "datasetView": "overview"
    }
}'

Publish with the JavaScript client

The JavaScript client wraps the same endpoints, with publish() and unpublish() for the publication state:

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const task = await client.tasks().create({
    actId: 'nwua9Gu5YrADL7ZDj',
    name: 'competitor-store-locations',
    title: "Track competitors' store locations",
    description: 'Looks up each brand name you provide on Google Maps and collects its store addresses, opening hours, and coordinates. Use the results to compare competitor coverage in a city or region and to find gaps in your own network.',
    input: { searchStringsArray: ['coffee shop'], maxCrossedDistance: 1000 },
});

await client.task(task.id).update({
    publicConfig: {
        seoDescription: "Get addresses and opening hours for any list of competitor brands.",
        inputSchemaFields: ['searchStringsArray', 'maxCrossedDistance'],
        datasetView: 'overview',
    },
});

await client.task(task.id).publish();

The Python client has no publish() yet. Use the API directly from Python until it lands.

Once published, the task gets its landing page and appears in the Actor's Example tasks tab.

Task landing page

Each published task gets its own standalone landing page on the Apify website, indexed by Google and readable by AI agents. Published tasks also appear in the Example tasks tab of the Actor's detail page, linking users directly to the landing page.

Example tasks tab on an Actor page listing published tasks with their titles.

URL structure

The landing page URL is built from your username, Actor name, and task name. For example:

https://apify.com/john/google-maps-scraper/examples/analyze-local-business-competitors

Keep the task name short, descriptive, and focused on the use case keyword.

Landing page content

A published task landing page showing the task title, description, input values, and output fields.

The landing page shows what you configured on the Publishing tab, in this order:

The task title and description, with a preview of the output fields
A Try for free button that lets users try the task right away
An example dataset table, if you generated example data in the Dataset schema section
The selected input fields with their configured values, and the output fields from the dataset view you selected
How it works: the steps to run the task, with a Sign up button
Integrations: tools such as Zapier, Make, and n8n, and code examples that run the task with its input
The FAQ, if you added one
Related tasks

The markdown version of the page includes the FAQ too. Search results show the SEO title and SEO description instead of the title and description.

After a user tries your task

When a user selects Try for free or Sign up, Apify creates a new task under their account with the same input configuration. The user can change, run, and manage it without affecting your original task. Your runs, data, and configuration stay private.

Next steps

Set up monetization for your Actor.
Track quality with the Actor quality score.