Perform checkout/checkin operations on accessories.

Accessories can be checked out to a user, asset, or location. Each checkout decrements the available quantity, and checkin increments it back.

Operations:

• checkout: Checkout an accessory to a user/asset/location (requires checkout_data with checkout_to_type and assigned_to_id)

• checkin: Checkin an accessory (requires checkout_id from the checkout record)

• list_checkouts: List all users who have this accessory checked out

Returns: dict: Result of the operation including success status and data

Query Snipe-IT activity logs and reports.

Provides access to the activity log which tracks all actions performed in Snipe-IT including checkouts, checkins, updates, and more.

Actions:

• list: List activity records with optional filtering

• item_activity: Get activity for a specific item (requires item_type and item_id)

Returns: dict: Activity records matching the query

Manage file attachments for assets.

Operations:

• upload: Upload one or more files to an asset

• list: List all files attached to an asset

• download: Download a specific file from an asset

• delete: Delete a specific file from an asset

Returns: dict: Result of the operation including success status and data

Generate printable labels for assets.

Provide either asset_ids or asset_tags to generate labels for specific assets. The labels will be saved as a PDF file to the specified save_path.

Returns: dict: Result with path to generated labels PDF

Get all licenses checked out to an asset.

Returns: dict: List of licenses associated with the asset

Manage maintenance records for assets.

Operations:

• create: Create a maintenance record for an asset (requires asset_id and maintenance_data)

• list: List maintenance records, optionally filtered by asset_id, search, or completed

• get: Get a single maintenance record by maintenance_id

• update: Update a maintenance record (requires maintenance_id and update_data)

• delete: Delete a maintenance record (requires maintenance_id)

• complete: Mark a maintenance record complete (requires maintenance_id; Snipe-IT v8.7+)

Returns: dict: Result of the operation including success status and data

Perform state operations on assets (checkout, checkin, audit, restore).

Operations:

• checkout: Check out an asset to a user, location, or another asset

• checkin: Check in an asset back to inventory

• audit: Mark an asset as audited

• restore: Restore a soft-deleted asset

Returns: dict: Result of the operation including success status and data

Manage asset checkout requests (as the authenticated user).

Allows users to request checkout of requestable assets. Assets must have the 'requestable' flag set (either on the asset or its model).

Operations:

• request: Submit a request to checkout an asset (requires asset_id)

• cancel: Cancel a pending request (requires asset_id)

• list: List the authenticated user's own pending checkout requests

• requestable: List assets the authenticated user may request

Note: Approving/denying requests is only available through the web UI - there are no API endpoints for these administrative functions.

Returns: dict: Result of the operation including success status

Track asset audit status for compliance.

Snipe-IT tracks when assets were last audited and calculates when they're due for re-audit based on the configured threshold.

Operations:

• due: Assets approaching their audit date (within warning threshold)

• overdue: Assets that have passed their audit date

• summary: Combined counts of due and overdue assets

The audit threshold is configured in Admin Settings → Notifications and determines the lookahead window for "due" assets.

Returns: dict: Audit status with asset details

Perform bulk operations on multiple assets at once (Snipe-IT v8.7+).

Operations:

• edit: Apply the same field changes to every asset in asset_ids (PATCH /hardware/bulk; requires fields)

• audit: Mark every asset in asset_ids as audited, optionally recording a note, location, and next audit date (POST /hardware/audit/bulk)

Snipe-IT applies per-asset permission checks, so one failing asset does not block the rest of the batch; check the returned payload for per-asset results.

Returns: dict: Result of the operation including success status and the API response

Perform checkout/checkin operations on components.

Components can be checked out to assets (not users). Each checkout decrements the available quantity.

Operations:

• checkout: Checkout component(s) to an asset (requires checkout_data with assigned_to asset ID)

• checkin: Checkin component(s) from an asset (requires checkout_id)

• list_assets: List all assets that have this component checked out

Returns: dict: Result of the operation including success status and data

Manage LDAP synchronization.

Operations:

• sync: Trigger LDAP user synchronization

• test: Test LDAP connection settings

Note: LDAP must be configured in Snipe-IT settings before use. Previously required CLI (php artisan snipeit:ldap-sync) or web UI.

Returns: dict: Sync results or connection test status

Manage file attachments for licenses.

Operations:

• upload: Upload a file to a license

• list: List all files attached to a license

• download: Download a specific file from a license

• delete: Delete a specific file from a license

Returns: dict: Result of the operation including success status and data

Manage license seat checkouts and checkins.

License seats can be assigned to users or assets.

Operations:

• list: List all seats for a license (requires license_id)

• checkout: Checkout a seat to a user or asset (requires license_id, seat_id, and checkout_data)

• checkin: Checkin a seat (requires seat_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT accessories with CRUD operations.

Accessories are quantity-based items (cables, adapters, peripherals) that can be checked out to users. Unlike assets, accessories are tracked by quantity rather than individually.

Operations:

• create: Create a new accessory (requires accessory_data with name, qty, and category_id)

• get: Retrieve a single accessory by ID

• list: List accessories with optional pagination and filtering

• update: Update an existing accessory (requires accessory_id and accessory_data)

• delete: Delete an accessory (requires accessory_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT assets with CRUD operations.

This tool handles all basic asset operations:

• create: Create a new asset (requires asset_data with at least status_id and model_id)

• get: Retrieve a single asset by ID, asset_tag, or serial number (uses dedicated bytag/byserial endpoints for reliable barcode scanning workflows)

• list: List assets with optional pagination, filtering by status/model/company/location/category/manufacturer/assigned_to

• update: Update an existing asset (requires asset_id and asset_data/extra_fields)

• delete: Delete an asset (requires asset_id)

Use extra_fields for fields not in AssetData: asset_eol_date, custom fields (snipeit*), etc. For both create and update, extra_fields are validated against the model's fieldset before sending. Invalid field names will be rejected with a list of available fields.

Note: list action returns full asset objects. With high limits this can produce large responses. Use pagination (limit/offset) to control response size.

Sortable fields for list: id, name, asset_tag, serial, model, model_number, last_checkout, category, manufacturer, notes, expected_checkin, order_number, companyName, location, image, status_label, assigned_to, created_at, purchase_date, purchase_cost

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT database backups.

Operations:

• list: List available database backup files

• download: Download a specific backup file

Note: Backup creation is triggered via web UI or CLI, not available via API.

Returns: dict: Backup list or download result

Manage Snipe-IT categories with CRUD operations.

Categories organize assets, accessories, consumables, components, and licenses.

Operations:

• create: Create a new category (requires category_data with name and category_type)

• get: Retrieve a single category by ID

• list: List categories with optional pagination and filtering

• update: Update an existing category (requires category_id and category_data)

• delete: Delete a category (requires category_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT companies with CRUD operations.

Companies allow you to segment your assets and users by organization. Useful for multi-tenant installations or tracking assets by subsidiary.

Actions:

• create: Create a new company (requires company_data with name)

• get: Retrieve a single company by ID

• list: List companies with optional pagination and filtering

• update: Update an existing company

• delete: Delete a company

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT components with CRUD operations.

Components are items that can be checked out to assets (not users). Examples: RAM, hard drives, CPUs, etc.

Actions:

• create: Create a new component (requires component_data with name, qty, category_id)

• get: Retrieve a single component by ID

• list: List components with optional pagination and filtering

• update: Update an existing component

• delete: Delete a component

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT consumables with CRUD operations.

This tool handles all basic consumable operations:

• create: Create a new consumable (requires consumable_data with name, qty, and category_id)

• get: Retrieve a single consumable by ID

• list: List consumables with optional pagination and filtering

• update: Update an existing consumable (requires consumable_id and consumable_data)

• delete: Delete a consumable (requires consumable_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT departments with CRUD operations.

Departments are organizational units within a company that can be assigned to users.

Actions:

• create: Create a new department (requires department_data with name)

• get: Retrieve a single department by ID

• list: List departments with optional pagination and filtering

• update: Update an existing department

• delete: Delete a department

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT depreciations with CRUD operations.

Depreciations define how assets lose value over time (e.g., 3-year straight-line).

Operations:

• create: Create a new depreciation (requires depreciation_data with name and months)

• get: Retrieve a single depreciation by ID

• list: List depreciations with optional pagination and filtering

• update: Update an existing depreciation (requires depreciation_id and depreciation_data)

• delete: Delete a depreciation (requires depreciation_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT custom fields with CRUD operations.

Custom fields allow you to add additional data fields to assets beyond the built-in fields. Fields must be associated with fieldsets to be used.

Actions:

• create: Create a new custom field (requires field_data with name, element)

• get: Retrieve a single field by ID

• list: List fields with optional pagination and filtering

• update: Update an existing field

• delete: Delete a field

• associate: Associate a field with a fieldset

• disassociate: Remove a field from a fieldset

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT fieldsets with CRUD operations.

Fieldsets are collections of custom fields that can be assigned to asset models. Each model can have one fieldset, and all assets of that model will have the custom fields defined in the fieldset.

Actions:

• create: Create a new fieldset (requires fieldset_data with name)

• get: Retrieve a single fieldset by ID

• list: List fieldsets with optional pagination

• update: Update an existing fieldset

• delete: Delete a fieldset

• fields: List all fields in a fieldset

• reorder: Reorder fields in a fieldset (requires field_order list of field IDs)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT permission groups with CRUD operations.

Groups are used to manage permissions for multiple users at once. Users can belong to multiple groups, and permissions are cumulative.

Actions:

• create: Create a new group (requires group_data with name)

• get: Retrieve a single group by ID

• list: List groups with optional pagination and filtering

• update: Update an existing group (including permissions)

• delete: Delete a group

Returns: dict: Result of the operation including success status and data

Manage CSV import operations for bulk data import.

The import workflow is: upload → process (with import_type and field_map). Snipe-IT saves the column mapping when the import is processed; there is no separate step to store it.

Operations:

• list: List all import files (with header row, first row and saved mapping)

• get: Get one import file's details (taken from the list; Snipe-IT has no single-import endpoint)

• upload: Upload a CSV file for import

• delete: Delete an import file

• process: Execute the import with import_data

Common field mappings for assets:

• asset_tag, name, serial, model_id, status_id

• purchase_date, purchase_cost, order_number

• notes, warranty_months, supplier_id

• location_id, company_id, category_id

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT predefined kits (bundles of models, licenses, accessories, consumables).

Kit CRUD:

• create: Create a kit (requires kit_data with name)

• get / list / update / delete: Standard operations by kit_id

Kit contents (requires kit_id and item_type):

• list_items: List the kit's models/licenses/accessories/consumables

• add_item: Attach an item to the kit (requires item_id; optional quantity)

• update_item: Change an attached item's quantity (requires item_id)

• remove_item: Detach an item from the kit (requires item_id)

Note: checking out a kit to a user is only available in the Snipe-IT web UI; there is no kit-checkout API endpoint. To perform a kit checkout via MCP, list the kit's items and check each out individually.

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT licenses with CRUD operations.

Licenses track software licenses with seat-based allocation.

Operations:

• create: Create a new license (requires license_data with name and seats)

• get: Retrieve a single license by ID

• list: List licenses with optional pagination and filtering

• update: Update an existing license (requires license_id and license_data)

• delete: Delete a license (requires license_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT locations with CRUD operations.

Locations represent physical places where assets are stored or deployed.

Operations:

• create: Create a new location (requires location_data with name)

• get: Retrieve a single location by ID

• list: List locations with optional pagination and filtering

• update: Update an existing location (requires location_id and location_data)

• delete: Delete a location (requires location_id)

• assets: List all assets at a specific location

• users: List all users assigned to a location

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT manufacturers with CRUD operations.

Manufacturers represent the companies that produce assets.

Operations:

• create: Create a new manufacturer (requires manufacturer_data with name)

• get: Retrieve a single manufacturer by ID

• list: List manufacturers with optional pagination and filtering

• update: Update an existing manufacturer (requires manufacturer_id and manufacturer_data)

• delete: Delete a manufacturer (requires manufacturer_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT asset models with CRUD operations.

Models define types of assets (e.g., 'MacBook Pro 14"', 'Dell XPS 15').

Operations:

• create: Create a new model (requires model_data with name and category_id)

• get: Retrieve a single model by ID

• list: List models with optional pagination and filtering

• update: Update an existing model (requires model_id and model_data)

• delete: Delete a model (requires model_id)

• assets: List all assets of a specific model

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT status labels with CRUD operations.

Status labels define the state of assets (deployable, pending, archived, etc.).

Operations:

• create: Create a new status label (requires status_label_data with name and type)

• get: Retrieve a single status label by ID

• list: List status labels with optional pagination and filtering

• update: Update an existing status label (requires status_label_id and status_label_data)

• delete: Delete a status label (requires status_label_id)

• assets: List all assets with a specific status label

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT suppliers with CRUD operations.

Suppliers are vendors from whom assets and consumables are purchased.

Operations:

• create: Create a new supplier (requires supplier_data with name)

• get: Retrieve a single supplier by ID

• list: List suppliers with optional pagination and filtering

• update: Update an existing supplier (requires supplier_id and supplier_data)

• delete: Delete a supplier (requires supplier_id)

Returns: dict: Result of the operation including success status and data

Manage Snipe-IT users with CRUD operations.

This tool handles all user operations:

• create: Create a new user (requires user_data with username, password, first_name)

• get: Retrieve a single user by ID

• list: List users with optional pagination and filtering

• update: Update an existing user (requires user_id and user_data)

• delete: Delete a user (requires user_id)

• restore: Restore a soft-deleted user (requires user_id)

• me: Get the currently authenticated user

Returns: dict: Result of the operation including success status and data

Manage file attachments for asset models.

Models can have attached files such as documentation, manuals, datasheets, or images that apply to all assets of that model.

Operations:

• upload: Upload a file to a model

• list: List all files attached to a model

• download: Download a specific file from a model

• delete: Delete a specific file from a model

Returns: dict: Result of the operation including success status and data

Get asset counts grouped by status label.

Returns a summary of how many assets are in each status, useful for dashboard displays and reporting.

Returns: dict: Asset counts by status label

Get Snipe-IT system information.

Returns version and installation details. Useful for compatibility checking and deployment verification.

Returns: dict: System version information

Get items checked out to a user.

Retrieves assets, accessories, licenses, and/or consumables that are currently checked out to the specified user. Also supports retrieving pending EULA acceptances.

Options:

• assets: Hardware assets checked out to user

• accessories: Accessories checked out to user

• licenses: License seats assigned to user

• consumables: Consumables checked out to user

• eulas: Pending EULA/acceptance items (items requiring user acceptance)

• all: All items except eulas (assets, accessories, licenses, consumables)

Note: The eulas option returns items requiring user acceptance via web portal. This helps identify users with pending acceptances for follow-up.

Returns: dict: Items checked out to the user

Manage user two-factor authentication.

Administrative functions for managing user 2FA settings.

Operations:

• reset: Reset a user's 2FA, requiring them to re-enroll

Note: This is an administrative function that affects user security.

Returns: dict: Result of the operation