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

# Get agent dependencies

> The secrets a custom agent requires and the toolkits it attaches, each with whether it is shared with the agent's team. Read-only: nothing is shared or revoked by this call. Sharing happens when the agent is shared with its team (visibility PATCH), when the owner edits `require_env_vars`, and when toolkits or tools are attached or detached. Readable by anyone who can run the agent.



## OpenAPI

````yaml /openapi/neo.public.openapi.json get /api/v1/agents/user/{agent_id}/dependencies
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: 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/agents/user/{agent_id}/dependencies:
    get:
      tags:
        - Agents
      summary: Get agent dependencies
      description: >-
        The secrets a custom agent requires and the toolkits it attaches, each
        with whether it is shared with the agent's team. Read-only: nothing is
        shared or revoked by this call. Sharing happens when the agent is shared
        with its team (visibility PATCH), when the owner edits
        `require_env_vars`, and when toolkits or tools are attached or detached.
        Readable by anyone who can run the agent.
      operationId: get-v1-agents-user-id-dependencies
      parameters:
        - $ref: '#/components/parameters/CustomAgentRef'
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AgentDependencies'
          description: Required secrets and attached toolkits with their sharing state
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
          description: Unauthorized
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
          description: >-
            `agent_not_found`: the agent does not exist or is not accessible to
            you.
      security:
        - BearerAuth: []
        - ApiKeyAuth: []
components:
  parameters:
    CustomAgentRef:
      description: >-
        Your own agent's ID (kebab-case slug), or the UUID of a custom agent:
        one you own, or a team-shared agent you can run (the `id` GET
        /api/v1/agents returns for it).
      in: path
      name: agent_id
      required: true
      schema:
        type: string
  schemas:
    AgentDependencies:
      description: >-
        The secrets an agent requires and the toolkits it attaches, and whether
        each is shared with the agent's team. A team-visible agent shares the
        owner's secret for every name in `require_env_vars` and every attached
        toolkit the owner owns; leaving the team, changing team or deleting the
        agent takes back what it shared, except what was shared before or
        another shared agent still needs. Never contains secret values or user
        ids.
      properties:
        secrets:
          items:
            $ref: '#/components/schemas/AgentDependencySecret'
          type: array
        toolkits:
          items:
            $ref: '#/components/schemas/AgentDependencyToolkit'
          type: array
      required:
        - secrets
        - toolkits
      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`. Custom agent authoring codes:

            `agent_not_found`, `agent_not_editable`, `agent_version_conflict`,

            `agent_edit_access_requires_team`, and `agent_invalid_editors`.
            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
    AgentDependencySecret:
      properties:
        name:
          description: The name as listed in the agent's `require_env_vars`.
          type: string
        note:
          description: Why the secret is not shared, when there is a specific reason.
          type: string
        state:
          description: >-
            `shared`: shared with the agent's team because the agent is.
            `pre_shared`: the owner had already shared it with that team;
            unsharing the agent leaves it shared. `missing`: the owner has no
            secret with this name. `other_team`: the owner's secret is shared
            with a different team and is left there. `private`: not shared (the
            agent is not team-visible, or the secret could not be shared; see
            `note`).
          enum:
            - shared
            - pre_shared
            - missing
            - other_team
            - private
          type: string
      required:
        - name
        - state
      type: object
    AgentDependencyToolkit:
      properties:
        credential_mode:
          description: >-
            How teammates authenticate when the toolkit is shared with the
            agent's team: `shared` uses the owner's bound secrets, `personal`
            each runner's own. Omitted when not shared with that team.
          enum:
            - personal
            - shared
          type: string
        id:
          format: uuid
          type: string
        name:
          type: string
        note:
          description: Why the toolkit is not shared, when there is a specific reason.
          type: string
        owner:
          $ref: '#/components/schemas/AgentActor'
        provided_by_editor:
          description: >-
            Whether an editor attached their own toolkit: true when the
            toolkit's owner is not the agent's owner.
          type: boolean
        state:
          description: >-
            `shared`: shared with the agent's team because the agent is.
            `pre_shared`: the owner had already shared it with that team;
            unsharing the agent leaves it shared. `not_yours`: owned by someone
            else, never shared by the agent. `other_team`: shared with a
            different team and left there. `private`: not shared (the agent is
            not team-visible, or the toolkit could not be shared; see `note`).
            `agent_scoped`: the owner's Global Toolkit (standalone tools) on a
            team-visible agent that attaches some of its tools one by one: those
            tools run for teammates inside this agent only, and the toolkit
            itself stays private.
          enum:
            - shared
            - pre_shared
            - not_yours
            - other_team
            - private
            - agent_scoped
          type: string
        toolkit_id:
          description: Toolkit slug.
          type: string
      required:
        - id
        - toolkit_id
        - name
        - owner
        - provided_by_editor
        - state
      type: object
    AgentActor:
      properties:
        username:
          description: >-
            The part of the user's email before the @, or "Unknown" for a
            deleted user.
          type: string
      required:
        - username
      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.