Open-source Freshservice asset management: the short answer
If your Freshservice renewal or asset unit pack decision is forcing a choice, or you need asset data on your own servers, GLPI Agent with GLPI's asset, contract and financial records covers discovery and inventory, and Snipe-IT covers simpler check-out tracking, with no per-asset fees for the software. GLPI is free under GPL-3.0 and Snipe-IT is free under AGPL-3.0, so your recurring costs shift to hosting, administration and any support contract you choose to buy. The 100-unit allowance per plan and the 500-unit packs described on this page reflect Freshservice's model at the time of writing. Confirm current unit terms, pack sizes and renewal conditions in writing with your Freshservice account team before you set a deadline.
You do not have to move the whole service desk to change asset management. GLPI can run its own ticketing, but many teams keep Freshservice for incidents, requests and approvals while GLPI or Snipe-IT becomes the system of record for hardware, software licenses and contracts. Decide early which system owns the asset identifier, because the link between tickets and assets has to survive the change. Ask whoever runs your Freshservice admin account to list which asset types, custom fields and asset-linked workflows are in use, since those determine how much of the inventory can be fed by discovery and how much must be re-keyed by hand.
The first practical check is whether your discovery needs are agent-based or manual. GLPI Agent collects hardware and software inventory from Windows, macOS and Linux endpoints and sends it to GLPI, which suits fleets where you want automatic records. Snipe-IT fits teams that mainly track who holds which laptop, purchase dates for depreciation and license seats. Pilot both against a representative sample of your estate, then compare the records each one produces with what Freshservice holds today before committing to either.
Which Freshservice asset capabilities map to GLPI and Snipe-IT
This table lists the core asset capabilities a team typically uses in Freshservice and shows which open-source option covers each one. Read the coverage column for where the fit is partial, and treat every item marked for confirmation as a question to test in your own environment before committing to a migration.
| Capability | Open-source option | Coverage note |
|---|---|---|
| Automated discovery and network scanning | GLPI Agent (with GLPI inventory) | GLPI Agent documents network discovery and inventory, but the scope, scan credentials and device coverage in your network must be confirmed in a pilot. |
| Hardware and software inventory | GLPI Agent | GLPI Agent collects hardware and software inventory on Windows, macOS and Linux. Confirm which device types and software fields your reports need. |
| Asset lifecycle and assignment | GLPI asset records and Snipe-IT | GLPI tracks assets with ITIL-linked tickets. Snipe-IT tracks who holds which device. Confirm lifecycle states and approval steps against your current workflow. |
| Contracts and licenses | GLPI contract management | GLPI covers contract management, but license compliance reporting per software title must be confirmed. Snipe-IT also tracks software license assignments. |
| Purchase and depreciation data | Snipe-IT and GLPI financial records | Snipe-IT records purchase dates for depreciation. GLPI includes financial management. Confirm which depreciation method and fields match your finance process. |
| Check-out to people | Snipe-IT | Snipe-IT checks out assets, licenses and accessories to people, which is its strongest fit. Confirm the sign-out and return forms your staff expect. |
| API access | GLPI API and Snipe-IT JSON REST API | Snipe-IT's REST API allows most actions available in its web interface. Confirm the GLPI API endpoints and any Freshservice integrations you rely on. |
When GLPI, Snipe-IT or both fit Freshservice asset management
Freshservice's asset units bundle discovery, inventory and lifecycle records into one metered product. The options below split those jobs: GLPI covers agent-based inventory with contracts and financial records, Snipe-IT covers simpler check-out tracking, and a hosted GLPI route keeps the same model with the vendor operating the platform.
GLPI with GLPI Agent
GLPI Agent collects hardware and software inventory and sends it to GLPI, and it also performs network discovery, which is the closest match to what Freshservice's discovery does for asset records. It fits teams with a mixed Windows, macOS and Linux estate that need automated inventory rather than manual entry. The trade-off is that you operate a PHP web application and a MariaDB or MySQL database, and you must deploy and update agents across endpoints. Confirm agent coverage for your operating systems and your network discovery ranges before choosing.
GLPI contracts and financial records
GLPI's contract management and financial modules hold licenses, maintenance terms, purchase data and depreciation-related records alongside each asset. This matters when your Freshservice asset units are tied to renewal dates and budget reporting, because the same record can drive both inventory and cost questions. The trade-off is data entry: contract and financial fields are only as current as the process that maintains them. Confirm with finance which fields they need and who owns updates before migrating.
Snipe-IT for check-out tracking
Snipe-IT tracks who holds which laptop, accessory or software license, with purchase dates for depreciation. It suits teams whose main question is custody, such as a help desk lending equipment to staff, and it does not depend on endpoint software. The trade-off is that assignments are recorded manually or through integrations, so the record is only as accurate as the check-out process. Confirm that check-in and check-out steps are followed by your technicians and that your license count matches what you actually hold.
Combined GLPI and Snipe-IT pattern
Some teams keep GLPI as the system of record for discovered hardware, software and contracts, and use Snipe-IT for the loan desk, with check-out to people, consumables and accessories. This split keeps automated inventory separate from custody tracking. The trade-off is two systems to keep consistent, so you need a rule for which tool owns serial numbers and asset tags. Confirm whether you will sync data between them, and whether that sync is built, scheduled or manual.
GLPI Network as a hosted route
GLPI Network is Teclib's hosted offering for GLPI, with public cloud, private cloud and self-hosted subscription tiers. It fits organizations that want the GLPI model without operating the PHP and database stack, but it changes cost from a free license to a recurring per-user or per-tier fee. Public cloud is priced per user per month and private cloud has a 25-user minimum, so the cost depends on your user count and tier. Confirm where data is hosted, what support level you receive, and whether a 45-day free trial fits your evaluation timeline.
Running open-source asset records beside the rest of Freshservice
Many teams do not move ticketing, changes and the service catalog in the same project as assets. While both systems run, the asset record sits between them, so ownership, identifiers and user data need explicit rules. The cards below cover the integration points to settle before the first asset is moved.
Asset references on tickets
Freshservice tickets link to assets held in Freshservice, and those links will not follow an asset into GLPI on their own. Decide whether the ticket keeps a text reference, a stored asset tag, or a link into the external inventory. Ask Freshservice which asset fields and API endpoints are available for read and write, and whether the integration you plan to use can create or update those references. Test this with a few real tickets before you rely on it.
Ownership of asset data
During the overlap, one system must be the authority for each asset attribute. A common split is to let GLPI Agent own hardware and software inventory while Freshservice keeps assignment and lifecycle status, but the split must be written down. Without it, a field updated in one tool is overwritten by a sync job running from the other. Confirm which fields Freshservice will accept from an external source before you assign ownership.
User records and directory sync
Check-out and assignment depend on the same person existing with the same identifier in both systems. If both tools sync from Active Directory, Entra ID or another directory, confirm that the matching attribute, such as the email address or employee ID, is identical across them. Snipe-IT's LDAP sync and SAML login are documented options if you adopt it for check-out, and GLPI authenticates against LDAP and other external methods. Mismatched users create orphaned assignments that are hard to spot later.
Split reporting across two systems
Until the move is finished, reports on asset counts, warranty dates or ticket-linked hardware may need data from both tools. Decide which system produces each report and how the figures are reconciled before an audit or budget review. Ask Freshservice what reporting exports and API access are included in your plan so the reconciliation job does not depend on manual copying. Record the reporting owner for each figure.
A single source of truth for asset IDs
Every asset needs one identifier that appears in both systems, such as a serial number or a generated asset tag. Without it, the same laptop can exist twice with different names, and a retirement in one tool leaves a live record in the other. Choose the identifier before the first import, validate it for duplicates, and document how new devices receive it. Consider which system issues IDs for new purchases during the overlap.
Duplicated license records
Software licenses and contracts recorded in both tools can be counted twice, which overstates spend and can hide true compliance gaps. Decide which system holds the license entitlement and which records installations, and reconcile counts before any true-up or renewal decision. Confirm how Freshservice handles software and license objects through its integration options, since this is where double counting most often starts.
What drives the cost of self-hosted asset inventory
The software line is the easiest to explain and the least of the cost. GLPI is free under GPL-3.0 and Snipe-IT is free under AGPL-3.0, and the Snipe-IT pricing page states that the self-hosted software is and always will be free. What you pay for is everything around it: servers or cloud instances for the application and database, the database itself (MySQL 8.0 or MariaDB for GLPI 11.0, per the installation docs), backups, TLS certificates, monitoring, and staff time. Freshservice's asset unit packs are a recurring line item that disappears in this model, but the infrastructure and administration lines take their place and recur every month.
Separate the one-time work from the recurring work before comparing totals. One-time items include planning, deploying GLPI Agent to endpoints, configuring discovery and inventory, defining asset types, locations and contract fields, and importing records from the Freshservice export or spreadsheets. Recurring items include patching PHP and the database, upgrading GLPI, keeping agents current, and reviewing inventory data quality. GLPI's update procedure requires backing up the database, files and the config directory (including glpi.key and glpicrypt.key) before replacing application files and running php bin/console db:update. Plugins are suspended after a new version is detected and must be reactivated after major updates, so budget admin time for every major release. Confirm the current major version your team will run with the vendor before you size that effort.
If you want someone else to carry some of that load, the options are priced differently. GLPI Network publishes public cloud at 19 euros per user per month and private cloud at 21 euros per user per month with a 25-user minimum, and self-hosted subscriptions from 100 euros per month (Basic, up to 10 agents and 500 assets) to 4,500 euros per month (Enterprise), according to the GLPI Network subscriptions page. Snipe-IT's hosted plans start at $399.99 per year and add email support, automated upgrades and server maintenance. Any implementation partner quote should state, in writing: a fixed scope for discovery and import, the number of endpoints and assets in scope, the hosting model and who pays for it, backup and restore testing, the upgrade and plugin reactivation process, support hours and response targets, and any recurring retainer, so you can compare it with your current Freshservice spend line by line.
How to move asset records out of Freshservice
This sequence moves hardware, software, contract and check-out records out of Freshservice into a GLPI test instance, then into production, so asset units can be retired without losing the inventory history. Each step closes with a check the team can verify before moving on.
Export the Freshservice account
A Freshservice account administrator opens Admin, Account, Export and requests the full service desk export. The data arrives as XML at the registered agent email address, so the administrator should confirm they can open the attachment and store it in a restricted location, since it contains personal data about agents and requesters. The step is done when the complete archive is saved and a copy is checked for completeness against the record counts shown in the Freshservice asset list.
Inventory the asset structure in the export
Before any mapping, the team opens the XML and confirms which elements hold assets, asset types, software, contracts, assignments and check-out history, because element names and nesting must be read from the actual file and not assumed. Record each field with its sample value and note which records are linked to tickets. The output is a field inventory sheet that lists every asset attribute, its source element and any gaps, such as fields that exist in the UI but are missing from the export.
Decide the target model for each asset type
The team decides how hardware, software licenses, contracts and check-outs will be represented in GLPI. GLPI covers asset inventory, configuration items, contract management and financial records, so most teams map computers, monitors and network devices to GLPI asset types, licenses to software records and contracts to GLPI contract objects. Teams that need simple check-out and check-in for loaned equipment should decide now whether Snipe-IT will hold that data. The output is a signed mapping decision table reviewed by the asset owner and finance.
Build a test GLPI instance
The platform team installs GLPI on a test host using the documented requirements: PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later for the current main branch, or PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6 for GLPI 11.0. The web server document root must point to the public directory with URL rewriting enabled, and only MySQL and MariaDB are supported. The step is complete when the installer finishes, the admin login works and the team has backed up the config directory, including glpi.key and glpicrypt.key, which must be kept with any future restore.
Pilot GLPI Agent on a small device group
The team deploys GLPI Agent to a small, mixed group of Windows, macOS and Linux devices that IT already knows well. Agents collect hardware and software inventory and send it to the test GLPI instance, and the same agent can run network discovery if that is in scope. The team checks that each device appears once, that serial numbers and operating system data are populated and that software lists match what administrators expect. The step closes when the pilot inventory is reviewed and any agent configuration problems are logged.
Import asset and contract data into GLPI
Using the field inventory and mapping table, the team imports exported Freshservice asset records and contract data into the test instance, with one object type loaded at a time. Each import is compared with the source file, checking record counts, serial numbers, locations, owners and contract dates. Duplicates created by the agent pilot are merged in favor of the agent record, with the Freshservice ID kept in a comment field or external reference for traceability. The output is an import log and a list of exceptions that the asset owner has accepted or fixed.
Reconcile imported records with discovery results
The team compares the imported Freshservice records with the inventory collected by GLPI Agent across the full device estate, not just the pilot group. Records that appear only in Freshservice are investigated as possibly retired or unreachable hardware, and devices that appear only through discovery are assigned owners. Where check-out tracking is required for loaned laptops, phones or accessories, the team runs Snipe-IT in parallel for those assets only and reconciles its records with GLPI. The step is complete when the open exceptions list has an owner and a decision for each row.
Cut over and retire Freshservice asset units
After sign-off from the asset owner and finance, the team moves production inventory to GLPI, switches agent reporting to the production instance and stops new asset entries in Freshservice. Before cancelling or reducing asset units, the team keeps the final export and confirms with Freshservice how asset unit usage is billed for the remaining term. The step is complete when GLPI is the system of record, agents report to it without errors and a dated archive of the Freshservice export is stored with the change record.
What buyers ask before replacing Freshservice asset units
What does replacing Freshservice asset units with GLPI cost in effort and components?
The software license is not the main cost. GLPI is free under GPL-3.0, and Snipe-IT is free under AGPL-3.0 for self-hosting, so the recurring costs are the servers, database, backups, monitoring and the staff time to run them. The one-time costs are the migration of asset records, discovery rollout to endpoints and the configuration of asset types, contracts and financial fields. Ask any implementation partner for a written quote that separates these components, states who performs each task, and lists what is one-time and what recurs. If you want GLPI Network, the subscriptions page lists per-user cloud pricing and self-hosted tiers, which you should compare against your own hosting and staff estimate.
How long does an asset management migration to GLPI take?
No fixed duration can be given without a defined scope, so ask for one in writing. The main drivers are the number of asset records to clean and map, how many endpoints need the GLPI Agent, how many network segments you want discovered, how many contract and financial fields you use in Freshservice, and how quickly your team can review results. Rollout tends to move faster when inventory data is already clean in a spreadsheet or CMDB export, and slower when asset ownership and naming conventions must be agreed first. Request a written timeline tied to the agreed deliverables.
What must our team provide before discovery and inventory work starts?
Plan for four inputs. First, an export of current asset records and any related contracts or license data. Second, directory access, such as LDAP or Active Directory read access, so that asset owners can be matched to users and departments. Third, a defined network scope for discovery, including subnets, VLANs and any segments that must be excluded. Fourth, named administrators who can approve field mappings, decide on asset lifecycle states and test the agent rollout. Without the fourth item, most delays come from waiting for decisions rather than from technical work.
Can our own IT staff do this migration without an outside partner?
Yes, if you have an administrator comfortable with Linux or Windows servers, PHP and MariaDB or MySQL, web server configuration and scripted deployment of agents. GLPI's installation documentation covers the document root, URL rewriting and the update procedure, which includes backing up the database, files and the config directory with glpi.key and glpicrypt.key. Recurring work includes applying updates, reactivating plugins after major upgrades and keeping backups tested. Decide honestly whether that work fits in your team's existing schedule, because it is ongoing, not a one-time project.
How does GLPI Agent differ in scope from Freshservice discovery?
GLPI Agent collects hardware and software inventory from endpoints and sends it to GLPI. It also performs network discovery and inventory, package deployment and remote ESX inventory, and it runs on Windows, macOS and Linux. Freshservice discovery focuses on its own asset discovery workflow inside the hosted product. Confirm in your own environment which device types, operating systems and network devices you need to inventory, because agent coverage for network hardware, mobile devices and specialist appliances may differ from what Freshservice currently provides to you.
Does Snipe-IT replace our asset records or only track check-outs?
Snipe-IT covers more than check-outs. It tracks who has which laptop, purchase dates for depreciation and software licenses, and it supports checking out assets, licenses and accessories to people, along with consumables and components. It is a simpler asset register than GLPI, which also covers contracts, financial records and ITIL processes. If your asset management needs are mainly ownership, check-out and lifecycle tracking, Snipe-IT may be enough. If you rely on Freshservice for contracts, service linkage and financial management, confirm which of those fields you need before choosing either tool or running both.
What does a fixed-scope DeployOpen engagement cover for this replacement?
DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own infrastructure, including cloud accounts, data centers or air-gapped networks. For this replacement, a fixed-scope engagement would typically define the GLPI or Snipe-IT deployment, the asset data mapping, the agent rollout, directory integration, backup and update procedures, and documentation. Scope, deliverables and timelines are agreed in writing before work starts. DeployOpen does not publish a price list, so request a written scope and quote that lists each deliverable, your responsibilities and any ongoing support retainer.
Choosing between agent-based inventory and check-out tracking
This fits a team with a large fleet of laptops, desktops and servers that needs hardware and software inventory collected automatically rather than typed in by hand. GLPI with GLPI Agent is the better match here, because the agent reports inventory to GLPI on each device and also supports network discovery. The main requirement is the GLPI platform itself: the README lists PHP 8.3 or later and MariaDB 10.11 or later or MySQL 8.0 or later for the current major line, and the installation docs list older versions for GLPI 11.0, so confirm which line you will deploy.
- Agent coverage: Confirm that your operating systems are supported by GLPI Agent, which runs on Windows, macOS and Linux.
- Deployment method: Decide how agents are pushed to devices, through your endpoint management tool or a script, and who maintains that process.
- Network discovery: Check whether you need discovery of unmanaged devices, which the agent also performs.
- Database sizing: Ask your database administrator to plan capacity for inventory data from every device, since it grows with the fleet.
- Web server setup: Plan for the document root to point to GLPI's public directory, as the installation docs require.
Confirm your device count, operating systems and how agents will be deployed before you commit to this design.
This fits a team with fewer assets that mostly tracks who holds which laptop, accessory or software license, with less need for automated scanning. Snipe-IT is built for this pattern: it checks assets, licenses and accessories out to people and tracks consumables and components such as RAM and hard drives. Its requirements are lighter, with PHP 8.2 or later and below 8.6, MySQL 5.7 or later or MariaDB, and Apache with mod_rewrite or IIS with URL Rewrite, and a Docker image is available.
- Check-out workflow: Confirm that your staff process matches check-out and check-in records for people, accessories and consumables.
- Hardware fit: Confirm your PHP version is within the supported range, since the requirement stops below 8.6.
- Directory login: Check whether LDAP or Active Directory sync or SAML login with your identity provider is needed for staff accounts.
- Integration needs: Confirm whether the REST API covers the actions your scripts or onboarding tools require.
- Software licenses: Decide whether purchase dates and license seats must be tracked for depreciation.
Confirm the asset types you track and whether any automated inventory is needed before choosing this option over GLPI.
This fits a team that needs contracts, warranties, purchase costs and financial records linked to each asset, often for budgeting, renewals or audit evidence. GLPI covers contract management and financial management alongside its asset inventory, so records sit in one system with the tickets and configuration items they relate to. This is the case where GLPI usually fits better than Snipe-IT, although Snipe-IT does track purchase dates for depreciation and license records.
- Contract records: List the contract types, renewal dates and vendors you need to link to assets and suppliers.
- Financial data: Confirm which cost, depreciation and budget fields your finance team requires, then test them in a trial instance.
- Data ownership: Decide who owns the contract data and who can view it, and set access rules in GLPI before loading records.
- Migration source: If records come from spreadsheets or another tool, plan the import and validation step.
- Authentication: Confirm how users sign in, since GLPI tries the internal database, LDAP, IMAP and other external methods in order.
Confirm which contract and financial fields you need and whether finance must sign off on the data model before you build.
How DeployOpen scopes and delivers an asset module replacement
DeployOpen plans and implements self-hosted open-source platforms inside your own infrastructure, including GLPI for asset inventory and contract records or Snipe-IT for simpler check-out tracking. Each engagement starts with a written scope that defines which asset data, agents and integrations are in and out before any work begins.
How we scope
- Inventory which asset classes, sources and discovery agents Freshservice currently covers today.
- Decide whether GLPI's inventory, contract and financial records or Snipe-IT's check-out model fits each team's workflow.
- Agree the written scope, deliverables and timeline with you before any work starts, as engagements are fixed-scope.
How we build
- Deploy GLPI or Snipe-IT and GLPI Agent in your cloud account, data center or air-gapped network.
- Configure authentication against your existing directory, such as LDAP or SAML, as agreed in the scope.
- Test imported asset records, agent collection and access rules against the acceptance criteria in the written scope.
How we hand over
- Document the architecture, configuration, data mapping and the Freshservice export fields that were carried over.
- Provide runbooks for backups, GLPI update steps and agent deployment so your staff can operate the system.
- Confirm with you what remains outside the scope, such as hardware contract renewals or license reconciliation, before closing the engagement.
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer after handover.
- Plan version upgrades with you, including GLPI's documented backup and plugin reactivation steps.
- Ask any retainer provider for response expectations in writing, since these depend on the agreed support terms.
