> For the complete documentation index, see [llms.txt](https://support.attackforge.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://support.attackforge.com/app/modules/assets.md).

# Assets

## Overview

The Assets module brings all your assets into one place. Here you can define new assets, store their properties and metadata, and assign them to projects and groups. Assets are the things you test, such as applications, hosts, networks and APIs. They make up a project's scope, and every vulnerability is linked to the assets it affects.

Assets come in four ways: created by hand, imported in the UI, sent through the Self-Service API, or created automatically when vulnerabilities are imported. Libraries group them and control who can view or edit them. Assets are then used in project scope, linked to vulnerabilities, and can be archived and restored.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FK7llEf1x7W1LePFx4TpJ%2Fassets-at-a-glance.svg?alt=media&amp;token=d1a56f5a-7a07-4807-8f39-c30b598a02f0" alt=""><figcaption></figcaption></figure>

You can import assets with the UI import option, or with the Self-Service APIs, for example from your CMDB.

Administrators can turn the Assets module on or off in the Administration module.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FjDkyV1fM9z7Lxx4TrkGK%2FScreenshot%202026-11-10%20at%202.09.04%E2%80%AFpm.png?alt=media&amp;token=c290157e-a9ee-4b35-92b5-e710ebd956ae" alt=""><figcaption></figcaption></figure>

When the module is on, the scope sections on projects show the assets from this module.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FtT7A66kFip52jYuTT4Fp%2FScreenshot%202026-11-10%20at%202.14.46%E2%80%AFpm.png?alt=media&amp;token=a3ae815f-c137-4f39-8a08-fe95a0fdb558" alt=""><figcaption></figcaption></figure>

## Why it matters

* **One inventory, not one per project.** The same asset is used across every project that tests it, so its history builds up over time.
* **See risk by asset.** Each asset shows its vulnerabilities, so you can see which systems carry the most risk.
* **Fewer duplicates.** Assets are shared across libraries, projects and imports instead of being re-created each time.
* **Control who sees what.** Asset libraries let each customer, business unit or team see and manage only their own assets.

## Who uses it

| Who                              | To                                                                        |
| -------------------------------- | ------------------------------------------------------------------------- |
| **Administrators**               | Turn the module on, set up asset fields and libraries, and control access |
| **Security and asset owners**    | Keep the asset inventory up to date, and see vulnerabilities by asset     |
| **Testers**                      | Choose assets for a project's scope, and link findings to them            |
| **Customers and business units** | See, and if allowed, update their own assets                              |
| **Integration teams**            | Keep assets in sync with a CMDB through the Self-Service API              |

## Set up asset fields

Create custom asset fields in the Administration module.

Custom field access controls let you show different asset forms and fields to different roles, groups or users. That way each customer, business unit, team or person sees the fields that fit their needs. See [Custom fields and forms](https://support.attackforge.com/app/getting-started/custom-fields-and-forms).

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FJtJj1uUxVvaI5INnO2Y8%2FScreenshot%202026-11-10%20at%202.18.02%E2%80%AFpm.png?alt=media&amp;token=dbe48315-1c73-4846-acea-f3a78a7f80d8" alt=""><figcaption></figcaption></figure>

## Group assets and control access with libraries

Asset libraries group your assets. They make assets easier to manage, and let you set them up for different customers, business units, networks, platforms or teams. Libraries are set up in the Administration module.

An asset can belong to one or more libraries. This shares access or ownership of the asset, and reduces duplicates.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FdGz111A5rD0tu3o0WoNi%2FScreenshot%202026-11-10%20at%202.18.51%E2%80%AFpm.png?alt=media&amp;token=10f0af29-31a9-4936-87f8-68c87fc907ed" alt=""><figcaption></figcaption></figure>

### Library access

Each library's access controls decide who can view or edit its assets. Access can be given to roles, groups or users.

| Access   | What people can do                                                                               |
| -------- | ------------------------------------------------------------------------------------------------ |
| **View** | See the library's assets, and any of their vulnerabilities they can reach through their projects |
| **Edit** | Change the assets, archive them, and link them to more libraries                                 |

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FzFaeHmFC2BXtPm0BtWHL%2FScreenshot%202026-11-10%20at%202.20.40%E2%80%AFpm.png?alt=media&amp;token=6dad4c9e-fe8a-485e-845b-b40d38d5dc00" alt=""><figcaption></figcaption></figure>

## Uncatalogued assets

Assets that aren't in any library are uncatalogued. Access to uncatalogued assets can be restricted in the Administration module.

{% hint style="info" %}
**Important:** people without Edit access to at least one library, or to uncatalogued assets, can't import vulnerabilities on a project. Imports create assets, so they need somewhere to put them.
{% endhint %}

## Add assets to libraries in bulk

Use the bulk actions to add many assets to libraries at once.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FRp9FDDkxc2P6fIClwTdt%2FScreenshot%202026-11-10%20at%202.21.55%E2%80%AFpm.png?alt=media&amp;token=38f47def-bd99-4586-a681-cac7e2811a95" alt=""><figcaption></figcaption></figure>

## Create an asset

Click the `New Asset` button.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FwDFTyqeYLnrFskKYHUEY%2FScreenshot%202026-11-10%20at%202.22.43%E2%80%AFpm.png?alt=media&amp;token=a1f4dd9f-6806-4e9d-842f-8b4b52da463d" alt=""><figcaption></figcaption></figure>

## View and update an asset

Click an asset's name to open its details. From there you can update the asset and see its vulnerabilities.

{% hint style="info" %}
**Important:** renaming an asset also renames it on every project and vulnerability it's linked to.
{% endhint %}

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fy9tssNEcqzd5ZDRdcUdW%2FScreenshot%202026-11-10%20at%202.25.13%E2%80%AFpm.png?alt=media&amp;token=14b9f83f-b430-4ed9-a653-7338285b5a10" alt=""><figcaption></figcaption></figure>

## Import assets

You can import assets from the Assets module with the UI import option, or with the Self-Service RESTful API.

## Import in the UI

1. In the Assets module, choose the import option.
2. Upload your file.
3. Match the columns in your file to AttackForge's asset fields.
4. Check the preview.
5. Run the import.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FMJOhPdZM5g5t5OvaOPh6%2FScreenshot%202026-11-10%20at%202.25.53%E2%80%AFpm.png?alt=media&amp;token=885cc471-d18b-401a-a4eb-24aa02f241f9" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FLuImcUBvDYX1Iqkn13lT%2FScreenshot%202026-11-10%20at%202.26.28%E2%80%AFpm.png?alt=media&amp;token=158e13e2-e9de-4c65-94c7-9d8a2ff2e9ca" alt=""><figcaption></figcaption></figure>

## Import with the Self-Service API

Use the Self-Service RESTful API to create and update assets from another system, such as your CMDB, so AttackForge stays in sync without manual imports. You need access to the API methods you use. See [Self-Service RESTful API](https://support.attackforge.com/app/automations-and-integrations/self-service-restful-api.md).

## Archive an asset

You can archive assets. If you archive one by mistake, restore it from the `Archived Assets` section. Only Administrators can view and restore archived assets.

{% hint style="info" %}
**Important:** archiving an asset from the library doesn't delete it from projects, or from the vulnerabilities it's linked to.
{% endhint %}

## Import vulnerabilities on a project

When you import vulnerabilities, AttackForge checks whether each affected asset already exists in the library. If it doesn't, AttackForge creates it automatically. This keeps the asset inventory complete without extra work.

## Automate your asset inventory

Keeping assets up to date by hand doesn't scale. AttackForge gives you three building blocks to automate it:

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fq20tSiWino3KXy69koO9%2Fasset-automation-at-a-glance.svg?alt=media&amp;token=78e32935-1b7f-4a21-8869-89d0eed08317" alt=""><figcaption></figcaption></figure>

| Building block               | What it does for assets                                                                                                                                                                                                                                                  |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Custom fields**            | Store the data your automations need on each asset, such as a CMDB ID, business owner, criticality, testing frequency, last tested date or discovery source. See [Custom fields and forms](https://support.attackforge.com/app/getting-started/custom-fields-and-forms). |
| **Self-Service RESTful API** | Create, update and find assets, and create project requests, from your own systems. See [Self-Service RESTful API](https://support.attackforge.com/app/automations-and-integrations/self-service-restful-api).                                                           |
| **Flows**                    | Run automations inside AttackForge, triggered by events or on a schedule, that call AttackForge and other systems' APIs. See [Flows](https://support.attackforge.com/app/automations-and-integrations/flows).                                                            |

The three scenarios below are examples. Field names are examples too.

### Keep assets in sync with your CMDB

Your CMDB is usually the source of truth for what you own. Syncing it with AttackForge means testers always scope against current assets, and findings are linked to the right owner.

1. Add custom asset fields for the CMDB's details, such as `CMDB ID`, `Business Owner` and `Environment`.
2. Create a Flow that runs on a schedule, or is triggered by your CMDB.
3. In the Flow, fetch new and changed records from your CMDB's API.
4. Match each record to an AttackForge asset by `CMDB ID`. Create the asset if it doesn't exist, or update it if it does, with the Self-Service RESTful API.
5. Add each asset to the right asset library, such as one per business unit, so the right people can see it.
6. Optionally, send asset changes back to the CMDB, such as the number of open vulnerabilities, when vulnerability events fire.

### Request testing for assets that are due

Most testing programmes set how often each asset must be tested, often by criticality. An automation can check this for you and start the work.

1. Add custom asset fields for `Criticality`, `Testing Frequency` and `Last Tested`.
2. Create a Flow that runs on a schedule, such as weekly.
3. In the Flow, find assets whose `Last Tested` date plus their `Testing Frequency` is now, or soon. For example, Critical assets every 6 months and Low assets every 2 years.
4. For each asset that's due, create a project request with the Self-Service RESTful API, with the asset in scope.
5. The request then follows your normal review. Authorised users are notified, and can approve it to create the project automatically. See [Requesting a project](https://support.attackforge.com/app/getting-started/requesting-a-project).
6. When testing finishes, update the asset's `Last Tested` date, so the cycle starts again.

### Catalogue assets from Attack Surface Management tools

Attack Surface Management (ASM) tools discover internet-facing assets you may not know about. Bringing them into AttackForge supports Continuous Threat Exposure Management (CTEM) and continuous testing: you discover exposure, test it, fix it and track it in one place.

1. Add custom asset fields such as `Discovery Source`, `First Seen`, `Last Seen` and `Exposure`.
2. Create a Flow that runs on a schedule, or is triggered by your ASM tool's webhook.
3. In the Flow, fetch discovered assets from the ASM tool's API.
4. Create new assets, or update existing ones, with the Self-Service RESTful API. New, unexpected assets can go into a "Newly discovered" library for triage.
5. Flag assets for testing, or create a project request for them, using the same approach as in "Request testing for assets that are due".
6. Track each asset's vulnerabilities and retests over time. Use [Portfolios](https://support.attackforge.com/app/modules/portfolios) and [Analytics](https://support.attackforge.com/app/modules/analytics) to report exposure for your CTEM programme.

{% hint style="info" %}
**Note:** automations need access. Give the Flow or service account access to the Self-Service RESTful API methods it uses, and Edit access to the asset libraries it writes to. See [Working with service accounts](https://support.attackforge.com/app/getting-started/working-with-service-accounts).
{% endhint %}

## Tips

* **Plan your libraries first.** Decide how to group assets, such as by customer, business unit, network, platform or team, before importing.
* **Give access to libraries through groups**, so it's easy to keep up to date.
* **Put shared assets in more than one library** instead of creating duplicates.
* **Keep assets in sync with your CMDB** using the Self-Service API.
* **Rename with care.** Renaming an asset renames it on every linked project and vulnerability.
* **Check that testers have Edit access** to at least one library, or to uncatalogued assets, before they import vulnerabilities.
* **Archive rather than recreate.** Archived assets can be restored, and stay on their projects and vulnerabilities.

## FAQ

**Why can't I see the Assets module?** An Administrator may have turned it off. It's turned on or off in the Administration module.

**Can an asset be in more than one library?** Yes. This shares access or ownership, and reduces duplicates.

**What can people with View access to a library do?** See its assets, and any of their vulnerabilities they can reach through their projects.

**Why can't a tester import vulnerabilities?** They need Edit access to at least one library, or to uncatalogued assets.

**What happens if I rename an asset?** It's renamed on every project and vulnerability it's linked to.

**Does archiving an asset remove it from projects?** No. It stays on its projects and linked vulnerabilities. You can restore it from `Archived Assets`.

**Do I need to create assets before importing vulnerabilities?** No. If an affected asset doesn't exist in the library, AttackForge creates it automatically.

**Can I import assets from our CMDB?** Yes, with the UI import option or the Self-Service RESTful API.

## Related pages

* [Concepts and Access](https://support.attackforge.com/app/getting-started/concepts-and-access)
* [Custom fields and forms](https://support.attackforge.com/app/getting-started/custom-fields-and-forms)
* [Groups](https://support.attackforge.com/app/modules/groups)
* [Projects](https://support.attackforge.com/app/modules/projects)
* [Vulnerabilities](https://support.attackforge.com/app/modules/vulnerabilities)
* [Self-Service RESTful API](https://support.attackforge.com/app/automations-and-integrations/self-service-restful-api)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://support.attackforge.com/app/modules/assets.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
