> ## Documentation Index
> Fetch the complete documentation index at: https://docs.neo.projectdiscovery.io/llms.txt
> Use this file to discover all available pages before exploring further.

# List tasks

> List the current user's own tasks with cursor-based pagination and optional status/scheduled filters. Team-visible tasks owned by teammates are excluded from this list by default, but may still be accessed directly by ID when authorized.



## OpenAPI

````yaml /openapi/neo.public.openapi.json get /api/v1/tasks
openapi: 3.1.0
info:
  contact:
    name: ProjectDiscovery
    url: https://neo.projectdiscovery.io
  description: Neo API Server - Security agent orchestration platform
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0
  title: Neo API
  version: 1.0.0
servers:
  - description: Production
    url: https://neo.api.projectdiscovery.io
  - description: Development
    url: https://neo.api.dev.projectdiscovery.io
  - description: Local development
    url: http://localhost:8080
security: []
tags:
  - description: Task execution and management
    name: Tasks
  - description: Agent listing and management
    name: Agents
  - description: Public agent directory
    name: Agent Directory
  - description: User file storage management
    name: Files
  - description: User working memory management
    name: Memory
  - description: Scheduled and recurring task management
    name: Schedules
  - description: Knowledge base and semantic search
    name: Knowledge
  - description: Encrypted user credentials and API keys
    name: Secrets
  - description: Neo API key management for programmatic access
    name: API Keys
  - description: User profile and account information
    name: User
  - description: Task and LLM usage tracking
    name: Usage
  - description: Bring Your Own Key provider management
    name: BYOK
  - description: Connect personal AI provider accounts and select them as a model source
    name: AI Connections
  - description: Model discovery and capabilities
    name: Models
  - description: Third-party integrations
    name: Integrations
  - description: Skill knowledge documents for agent prompts
    name: Skills
  - description: User-authored tools and toolkit management
    name: Dynamic Tools
  - description: Team management and member invitations
    name: Teams
  - description: Prompt library management and discovery
    name: Prompts
  - description: Slack bot integration for workspace installation and OAuth
    name: Slack
  - description: GitHub integration for PR reviews and repository management
    name: GitHub
  - description: Vulnerability issue tracking and management
    name: Issues
  - description: Subscription billing and plans
    name: Billing
  - description: Project management and member assignments
    name: Projects
  - description: SSH key pair generation and management for remote server access
    name: SSH Keys
  - description: Codebase structural analysis and mapping
    name: Codemaps
  - description: AI-generated codebase documentation and security analysis
    name: CodeWiki
  - description: Captured HTTP traffic query and replay
    name: Network Events
  - description: User and team API activity metadata
    name: Audit Logs
  - description: Vulnerability triage for HackerOne, GitHub, and Security Inbox
    name: Triage
paths:
  /api/v1/tasks:
    get:
      tags:
        - Tasks
      summary: List tasks
      description: >-
        List the current user's own tasks with cursor-based pagination and
        optional status/scheduled filters. Team-visible tasks owned by teammates
        are excluded from this list by default, but may still be accessed
        directly by ID when authorized.
      operationId: get-v1-tasks
      parameters:
        - description: Number of tasks to return (max 100)
          in: query
          name: limit
          required: false
          schema:
            default: 20
            maximum: 100
            minimum: 1
            type: integer
        - description: Cursor for pagination - return tasks after this ID (newer)
          in: query
          name: starting_after
          required: false
          schema:
            format: uuid
            type: string
        - description: Cursor for pagination - return tasks before this ID (older)
          in: query
          name: ending_before
          required: false
          schema:
            format: uuid
            type: string
        - description: |
            Filter by task status. Matches the status reported in the response,
            so `active` also covers resuming tasks and `error` also covers
            blocked ones.
          in: query
          name: status
          required: false
          schema:
            enum:
              - active
              - completed
              - error
              - pending
              - suspended
              - aborted
            type: string
        - description: >
            Filter by scheduled status. Defaults to 'false' when not provided,
            which

            hides scheduled-run tasks from the default list (each run of a
            schedule

            creates its own task). Pass 'true' to list only scheduled runs.
          in: query
          name: is_scheduled
          required: false
          schema:
            enum:
              - 'true'
              - 'false'
            type: string
        - description: >-
            Filter tasks by project ID. If omitted, returns only the current
            user's personal tasks.
          in: query
          name: project_id
          required: false
          schema:
            format: uuid
            type: string
        - description: Case-insensitive substring match on task title.
          in: query
          name: search
          required: false
          schema:
            maxLength: 500
            type: string
        - description: >
            Filter by task source. Defaults to 'web' when not provided, which
            hides

            integration- and triage-sourced tasks from the default list.

            Pass a specific source to list only tasks from that origin.
          in: query
          name: source
          required: false
          schema:
            enum:
              - web
              - github
              - slack
              - linear
              - jira
              - triage
            type: string
            x-enum-varnames:
              - GetV1TasksParamsSourceWeb
              - GetV1TasksParamsSourceGithub
              - GetV1TasksParamsSourceSlack
              - GetV1TasksParamsSourceLinear
              - GetV1TasksParamsSourceJira
              - GetV1TasksParamsSourceTriage
        - description: >-
            Filter tasks by visibility. Tasks without explicit visibility are
            private.
          in: query
          name: visibility
          required: false
          schema:
            enum:
              - private
              - unlisted
              - team
              - support
            type: string
        - description: >
            Include web tasks owned by current teammates when their visibility
            is team.

            In the personal task list, this always restricts the source to web,
            even

            if another source is supplied. Project-scoped lists ignore this
            option.

            Private, unlisted, and support tasks owned by teammates are never
            included.
          in: query
          name: include_team_tasks
          required: false
          schema:
            default: false
            type: boolean
        - description: >-
            Field to sort tasks by. Defaults to updated_at so recently-active
            tasks surface first.
          in: query
          name: order_by
          required: false
          schema:
            default: updated_at
            enum:
              - created_at
              - updated_at
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TaskListResponse'
          description: Task list with pagination info
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
          description: Bad request (e.g., both starting_after and ending_before provided)
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
          description: Unauthorized
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
          description: Internal server error
      security:
        - BearerAuth: []
        - ApiKeyAuth: []
components:
  schemas:
    TaskListResponse:
      properties:
        has_more:
          description: Whether there are more results available
          type: boolean
        tasks:
          items:
            $ref: '#/components/schemas/TaskSummary'
          type: array
        total:
          description: >-
            Total number of tasks matching the current filters (ignores
            pagination cursor)
          type: integer
      required:
        - tasks
        - has_more
      type: object
    ErrorResponse:
      properties:
        code:
          description: >
            Stable machine-readable error code — branch on this rather than

            matching the human `error`/`message` strings. `access_restricted`

            (HTTP 403) denies hosted Neo access under the access policy. On team

            invitations, param=email identifies a restricted recipient rather

            than the caller; show the error without redirecting the caller.
            Domain codes include

            `user_spending_cap_reached`, `project_spending_cap_reached`, and

            `insufficient_neo_credits`; Free/usage codes include

            `free_grant_challenge_required`, `free_usage_exhausted`,

            `free_task_budget_exhausted`, `model_not_available_on_free`,

            `sandbox_not_available_on_free` (cloud sandbox surfaces are not

            available on the Free plan; task files remain available from the

            task), `free_cannot_continue_managed_task` (a task that ran on the

            standard cloud sandbox cannot be continued on the Free plan; start

            a new task), `free_origin_not_supported` (integration-originated

            tasks are not available on the Free plan),

            `weekly_usage_limit_reached`, `billing_period_usage_limit_reached`,

            `topup_required`, `subscription_required`, and

            `isolated_workspace_purged`. Otherwise it mirrors the error kind

            (e.g. `forbidden`, `invalid_request`, `not_exists`,
            `already_exists`).
          example: user_spending_cap_reached
          type: string
        error:
          example: Bad request
          type: string
        error_id:
          description: Correlation id for a specific error instance, when present.
          type: string
        kind:
          description: Coarse error category (e.g. "forbidden request", "invalid request").
          example: forbidden request
          type: string
        message:
          description: |
            Human-readable detail (the kind prefixed to the error). For display,
            not for branching.
          type: string
        param:
          description: >-
            Field rejected by the policy; email for a restricted invite
            recipient.
          type: string
        turnstile_site_key:
          description: |
            Public Cloudflare Turnstile site key returned only with
            `free_grant_challenge_required`, so the client can complete the
            invisible verification before retrying the request.
          type: string
      required:
        - error
      type: object
    TaskSummary:
      properties:
        created_at:
          description: When the task was created
          format: date-time
          type: string
        created_by:
          description: Email of user who created the task
          type: string
        id:
          description: Task ID
          format: uuid
          type: string
        is_isolated:
          description: >-
            Whether the task runs in an ephemeral sandbox with no prior user
            context.
          type: boolean
        is_scheduled:
          description: Whether this task is scheduled
          type: boolean
        pending_approval_count:
          description: Number of tool calls awaiting user approval (0 when not suspended)
          type: integer
        project_id:
          description: Project ID if task is project-scoped (null for personal tasks)
          format: uuid
          type: string
        schedule_info:
          $ref: '#/components/schemas/ScheduleInfo'
        source:
          description: Source of the task (web, github, slack, linear, jira, triage)
          enum:
            - web
            - github
            - slack
            - linear
            - jira
            - triage
          type: string
        status:
          description: Current status of the task
          enum:
            - active
            - completed
            - error
            - pending
            - aborted
            - suspended
          type: string
        title:
          description: Task title
          type: string
        updated_at:
          description: When the task was last updated (stream run, rename, etc.)
          format: date-time
          type: string
        visibility:
          description: Who can access this task.
          enum:
            - private
            - unlisted
            - team
            - support
          type: string
      required:
        - id
        - title
        - created_at
        - updated_at
        - status
        - is_scheduled
        - source
      type: object
    ScheduleInfo:
      properties:
        execution_count:
          description: Total number of executions
          type: integer
        execution_info:
          $ref: '#/components/schemas/ExecutionInfo'
        last_executed_at:
          description: When the schedule was last executed
          format: date-time
          nullable: true
          type: string
        next_execution_at:
          description: When the schedule will next execute
          format: date-time
          nullable: true
          type: string
        scan_frequency:
          description: Frequency for recurring schedules
          enum:
            - hourly
            - daily
            - weekly
            - monthly
          nullable: true
          type: string
        schedule_id:
          description: Schedule ID
          format: uuid
          type: string
        schedule_name:
          description: Human-readable schedule name
          nullable: true
          type: string
        schedule_status:
          description: Current status of the schedule
          enum:
            - active
            - paused
            - completed
            - failed
          type: string
        schedule_type:
          description: Type of schedule
          enum:
            - recurring
            - one_time
          type: string
        start_time:
          description: Scheduled start time
          nullable: true
          type: string
      required:
        - schedule_id
        - schedule_type
        - schedule_status
        - execution_count
      type: object
    ExecutionInfo:
      properties:
        completed_at:
          description: When the execution completed
          format: date-time
          nullable: true
          type: string
        execution_id:
          description: Execution ID
          format: uuid
          type: string
        scheduled_at:
          description: When the execution was scheduled
          format: date-time
          type: string
        started_at:
          description: When the execution started
          format: date-time
          type: string
        status:
          description: Execution status
          enum:
            - pending
            - running
            - completed
            - failed
          type: string
      required:
        - execution_id
        - scheduled_at
        - started_at
        - status
      type: object
  securitySchemes:
    BearerAuth:
      bearerFormat: JWT
      description: JWT authentication token
      scheme: bearer
      type: http
    ApiKeyAuth:
      description: Neo API key (neo_sk_* prefix)
      in: header
      name: X-Api-Key
      type: apiKey

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.