Freshservice vs GLPI: when a self-hosted GLPI fits your service desk
Freshservice fits teams that want a managed SaaS service desk with vendor-run upgrades and no server team to staff. GLPI fits a different situation: the organization must host its ITSM data itself, the ITIL modules and inventory agent cover the workflows the team uses every day, and the team can operate PHP and either MariaDB or MySQL. GLPI is free under GPL-3.0, so the decision rests on what it costs to run, not on a license fee. The GLPI README lists the current requirements, which the team should check against its own platform standards before committing.
Three factors decide the fit. The first is the workflows and integrations the team actually uses: list the Freshservice incident, problem, change and service request flows, the approval paths, the SLAs, the service catalog and any connectors to identity, monitoring or chat tools, then confirm each one exists in GLPI or needs a plugin or custom work. The second is the hosting rule, since a data residency or sovereignty requirement can rule out SaaS regardless of features. The third is the admin hours the organization can staff. Upgrades require backing up the database, files and the config directory, including glpi.key and glpicrypt.key, and plugins are suspended after a new version is detected, so budget time for reactivation and testing on every release.
Before running a pilot, ask your Freshservice account team for the export you would need to move and list the custom fields, automations and reports that have no GLPI equivalent. Then ask two or three GLPI implementation partners for a written scope covering those gaps, the hosting design and the upgrade calendar. A quote that follows from that scope lets you compare the one-time migration work with the recurring hosting and admin effort, which is where the real cost difference sits.
Which option fits each buying scenario
This table matches common buying conditions to the option that fits better, and explains when each advantage matters. Read each row as a condition to test against your own requirements, because the answer changes with the condition. The main takeaway: GLPI fits best where data location and endpoint inventory drive the decision, while Freshservice fits best where server operations are scarce or bundled workflows carry the service desk.
| Scenario | Better fit | Why and when it matters |
|---|---|---|
| Ticket and asset data must stay on your own servers | GLPI | Applies when policy or regulation requires on-premises storage. Freshservice is vendor-hosted, so confirm residency terms in the contract. |
| Small admin group with no server operations | Freshservice | Applies when no one can own PHP, the database, the web server, backups and upgrades. GLPI adds all of these to your team. |
| Mostly Windows, macOS and Linux endpoints | GLPI | Applies when you need automatic hardware and software inventory. GLPI Agent runs on all three systems; confirm coverage for your fleet. |
| Heavy reliance on Freshservice-specific automations | Freshservice | Applies when workflows and integrations already run in the platform. Rebuilding them in GLPI may require plugins or custom code to verify. |
| Large marketplace of ready-made integrations | Freshservice | Applies when you depend on many prebuilt connectors. Check each GLPI plugin's maintenance and version compatibility before you commit. |
| Need a paid vendor support contract | GLPI | Applies when you want support from the maintainer. GLPI Network self-hosted plans run from 100 to 4,500 euros per month, per GLPI's subscriptions page. |
Where GLPI matches the way teams use Freshservice, and where to confirm
GLPI covers the core ITIL process areas most Freshservice teams run day to day. Its supplied scope includes incident, problem, change and service level management, asset inventory, configuration management, knowledge base and contract management, all under GPL-3.0 with no per-agent licence fee. Map each Freshservice process you use to a GLPI equivalent before anything else: incident queues and categories, problem records linked to incidents, change requests with their approvals, the asset register and its relationships, the knowledge base articles your agents search, and the contracts attached to hardware and software. Where a process has a clear GLPI record type, the migration question becomes configuration rather than new development.
Several areas need testing in a pilot rather than assumption. Confirm the workflow automation you depend on, since Freshservice's routing and trigger rules may not map one to one onto GLPI's rules engine and any automation builder you need. Test the service catalog layout, including how requesters see request forms, categories and approval paths. Check SLA rules end to end: escalation timing, business hours, and how approval flows interact with SLA clocks. Finally, list every third-party connector your team uses, such as monitoring, chat or identity tools, and confirm whether GLPI offers a native integration, an API route or a plugin, and who maintains it. Check each item against GLPI's current release notes, including the GLPI 12.0.0 notes, and against a trial run using your own workflows and sample tickets.
Capability, hosting and licensing compared side by side
This table compares how Freshservice and GLPI cover the ITSM, asset, data and operating needs that most IT teams have when they consider leaving Freshservice. Where no verified detail for Freshservice is available, the cell says what to confirm with the vendor, so the comparison stays accurate. The main takeaway is that GLPI's coverage is open to inspection, while your own team takes on hosting, upgrades and authentication.
| Capability | Freshservice | GLPI |
|---|---|---|
| Ticketing and ITIL incident, problem and change | Hosted service desk with ITIL-aligned modules; confirm which processes and approval flows your plan includes | Covers ITIL incident, problem and change management in the core product, with tickets, categories and workflows |
| SLA management | Confirm SLA policy types, escalation rules and reporting with Freshservice for your plan | Includes service level management; group-managed OLAs were added in GLPI 12.0.0 |
| Asset inventory and discovery | Asset management is licensed in unit packs; confirm how discovery and agent inventory are supplied and counted | GLPI Agent collects hardware and software inventory, performs network discovery and deploys packages on Windows, macOS and Linux |
| CMDB, contracts and financial records | Confirm CMDB relationship modeling, contract tracking and financial fields available on your plan | Provides configuration management, contract management and financial management in the same platform as tickets |
| Knowledge base | Built-in knowledge base; confirm article workflows, approval and access controls with Freshservice | Knowledge base rewritten in GLPI 12.0.0; confirm that the current layout meets your publishing and review needs |
| Authentication | Confirm supported single sign-on and directory options, including SAML and SCIM, for your tenant | Checks the internal database, then LDAP, IMAP and other methods such as REMOTE_USER, in that order |
| Hosting model | Vendor-hosted SaaS; confirm data center region, sub-processors and access controls in writing | Self-hosted on PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later; an official Docker image is available |
| Licensing | Commercial subscription priced per agent and per asset unit; confirm current terms, renewal and overage rules | GPL-3.0 and free to use; optional GLPI Network subscriptions add hosting and level 3 support |
| Upgrade method | Vendor-managed releases; confirm which changes need customer action and how much notice you receive | Back up the database, files and config directory including glpi.key and glpicrypt.key, replace files, then run php bin/console db:update; reactivate plugins after major updates |
How the GLPI Agent covers asset discovery and inventory
Freshservice tracks assets through its own asset units and discovery features, while GLPI pairs a central database with the GLPI Agent that runs on each device. The cards below cover the parts of that agent most relevant to replacing Freshservice's inventory work, and the checks to run before you commit.
Hardware and software inventory
The GLPI Agent collects hardware and software inventory from endpoints and sends it to GLPI, where records become assets. This matters if you currently rely on Freshservice discovery to populate asset records automatically. Check which fields your team needs, such as serial numbers, installed software and users, and confirm that the agent reports them into the asset types you already use in Freshservice.
Network discovery and inventory
The agent can perform network discovery and inventory, which helps find devices that have no agent installed, such as printers, switches and unmanaged hardware. This matters when your Freshservice asset count depends on devices people register by hand. Ask which discovery methods run from which hosts, and test the scan scope on a network segment you own before extending it across the estate.
Package deployment
The GLPI Agent can deploy packages to managed devices, which covers some of the software distribution work teams often pair with asset tools. If Freshservice handles software requests or deployments today, map each workflow to a GLPI deployment task and confirm how approvals and rollbacks are handled. Treat this as a separate project from inventory, with its own testing on a pilot group of machines.
Remote ESX inventory
The agent can perform remote inventory of VMware ESX hosts, which matters if your virtual infrastructure is tracked as assets. Confirm that your ESX versions and access credentials fit the agent's supported configuration, and decide which virtual machines should appear as assets and which should be linked to their host.
Platform support across endpoints
The agent runs on Windows, macOS and Linux. For a mixed fleet, this lets one inventory approach cover laptops, desktops and servers, but platform coverage does not guarantee every field reports the same way on every operating system. Build a list of your OS versions and device types, and compare the inventory output for each against what Freshservice shows today.
Successor to FusionInventory
The GLPI Agent is the successor of FusionInventory Agent. If you have an older FusionInventory deployment, plan the upgrade path and confirm that existing configuration and scheduling carry over. Before migrating, test agent rollout and reporting against your own fleet, including how often devices check in and whether reports arrive in GLPI as expected.
Hosting, data control and identity: what changes for your team
Moving from Freshservice to GLPI changes where ticket, asset and user data sits, who operates it and how staff authenticate. The cards below cover the decisions that follow from those changes, and the checks to make before you commit to a hosting model.
Data location and access
Freshservice runs as a vendor-hosted service, so your team relies on the vendor's data center location, access controls and support access model. With GLPI, you choose the location: your own servers, a provider in a jurisdiction you select, or GLPI Network cloud. Your administrators then control database access, backups and file storage. Confirm with Freshservice where data is stored and who at the vendor can access it, so you can compare the two on the same terms.
Hosting options for GLPI
You can run GLPI on your own servers or in an EU or other provider's data center that you contract directly. GLPI Network offers a managed cloud, in public or private cloud form, with a free 45-day trial that lets you test before deciding. Each option moves operating work to a different party. Ask the chosen host who patches the operating system, the web server, PHP and the database, and who holds the backup copies.
Authentication order
GLPI tries sign-in sources in a fixed order: the internal database first, then LDAP directories, then IMAP mail servers, then external methods such as REMOTE_USER. Accounts stored locally are checked before your directory, so decide whether local accounts should exist at all. Map each Freshservice agent and requester to a directory identity, and test that a leaver loses access in every source GLPI consults.
Database and PHP requirements
The GLPI README on the main branch lists PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later. The installation docs for GLPI 11.0 list PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6, and state that only MySQL and MariaDB are supported. Check which version line you deploy against, because these requirements differ. Your platform team must also plan for supported PHP and database patch levels across the life of the install.
Update and key handling
GLPI updates require a backup of the database, the files and the config directory, including the glpi.key and glpicrypt.key files. Losing those keys can leave encrypted data unreadable, so store them under the same controls as the database. Since GLPI 11.0, plugins are suspended after a new version is detected and must be reactivated after major updates, which adds a post-upgrade check to your change process.
Compliance evidence and audit scope
If your organization must demonstrate controls for an assessment, DeployOpen can plan and prepare the controls, configuration baselines and evidence for GLPI, including access reviews, backup records and change logs. DeployOpen does not issue audit reports, attestations or certifications. Independent auditors and certification bodies make those determinations. Ask your auditor which controls they expect to test in the GLPI environment and in the Freshservice contract before the migration starts.
What Freshservice and GLPI cost to run, one-time and recurring
Freshservice is a recurring subscription. You pay per agent on the plan named in your order form, and any asset management units beyond what that plan includes are sold as an add-on. Your own admin team handles configuration, but the platform itself, its hosting and its upgrades are carried by the vendor.
- Recurring subscription: the per-agent fee for your plan tier, multiplied by the number of agents you license and the billing term you chose.
- Asset units: a recurring add-on if your asset count exceeds the units included in your plan. Confirm the included count and the price of each additional pack in your own order form, since these figures vary by contract.
- One-time exit work: an account administrator can export the full service desk as XML, which arrives at the registered agent email address. Turning that export into GLPI tickets, assets and articles is a one-time project, and its size depends on how much history you keep.
- Internal admin time: recurring effort for workflows, SLAs, catalog changes and user administration, which your team carries even on a hosted product.
Cost moves most with agent count, asset volume and plan tier. Check the renewal date, notice period and any price-increase clause in your contract before you compare totals.
GLPI is free software under GPL-3.0, so there is no license fee. Your costs are the infrastructure you run it on, the people who install, patch and upgrade it, and the one-time work of moving your data and rebuilding your processes. The software cost is the smallest line in the model.
- One-time setup: installation, LDAP or other authentication setup, data import, and rebuilding SLAs, workflows and the service catalog. This work is done by your staff or by a services partner under a written scope.
- Recurring hosting: the servers, database, storage and network for the application, in your cloud account or data center. The GLPI README lists PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later, while the installation docs list older minimums for GLPI 11.0, so confirm the versions for your release.
- Recurring backups: backup storage for the database, files and the config directory, which must include the
glpi.keyandglpicrypt.keyfiles. - Recurring upgrades: each update requires backing up, replacing application files and running
php bin/console db:update. Since GLPI 11.0, plugins are suspended after a new version is detected and must be reactivated after major updates, so plan staff time for each release. See the GLPI update documentation.
Costs rise with asset count, number of concurrent users, high availability requirements and the number of plugins you depend on. Ask whether your internal team has the PHP and database skills to run it without an outside partner.
GLPI Network is the vendor's paid option, sold by Teclib', the company that edits GLPI. It adds a managed hosting or support layer on top of the free software, and it is optional. You pay a recurring subscription, and the price depends on whether you choose public cloud, private cloud or self-hosted support.
- Public cloud: 19 euros per user per month, according to the GLPI Network subscriptions page. A free 45-day trial is listed on the project site.
- Private cloud: 21 euros per user per month with a 25-user minimum, per the same subscriptions page. For illustration only, a 25-user private cloud at that rate would be 525 euros per month before any other terms.
- Self-hosted subscriptions: from 100 euros per month for the Basic tier (up to 10 agents and 500 assets) to 4,500 euros per month for Enterprise, which includes level 3 support and GLPI Network marketplace plugins.
- Recurring nature: every tier is a monthly charge, so the subscription keeps running after migration. It can replace part of your internal admin effort, but it does not remove the need for your own owners.
The main drivers are user count, tier and support level. Confirm which tier includes the support hours and plugin access you actually need before you assume it replaces internal staff.
A fair comparison needs both sides priced against the same scope, term and assumptions. Ask Freshservice and any GLPI implementation partner for figures in writing, and keep the scope, deliverables and exclusions visible in each document so that differences in price reflect differences in work.
- Freshservice totals: the agent count, plan tier, asset unit count and billing term for each year of the contract, plus renewal and price-increase terms.
- Migration scope: which data is in scope (tickets, assets, knowledge articles, workflows, SLAs, service catalog), what is excluded, and who performs the export and import.
- GLPI implementation: the hosting design, authentication setup, backup and restore testing, upgrade procedure, and hours or deliverables for each. DeployOpen plans and implements fixed-scope engagements, and its quotes follow from written scope.
- Support and upgrades: which GLPI Network tier, if any, is quoted, its support level, and whether upgrades and plugin reactivation are covered after go-live.
- Commercial terms: currency, tax treatment, payment schedule and the notice period for ending each subscription.
Check that every quote states what is excluded, since omitted items such as data cleanup or plugin rework are the most common source of later cost differences.
How a move from Freshservice to GLPI runs, at a high level
The sequence takes a Freshservice service desk from a full export through a tested GLPI instance, a pilot of inventory agents, and a parallel run to a cutover the team can sign off on.
Export the full Freshservice service desk
A Freshservice account administrator opens Admin, Account, Export and requests the full service desk export. The archive arrives as XML at the registered agent email address. The admin confirms the file opens, record counts look plausible against the Freshservice reports, and the file is stored in a restricted location. Done means the team holds a complete, verified copy outside the live service desk. Ask Freshservice support which fields are included in the export before relying on it for ticket history.
Inventory workflows, SLAs and the service catalog
The service desk owner lists every automation, approval flow, SLA target, escalation rule, service catalog item and custom field in Freshservice, with the team that uses each one. This is manual work: the XML export holds the data, but workflow logic and SLA policies must be read from the Freshservice admin screens and rebuilt in GLPI's ticket, SLA and change models. Done means a signed inventory that marks each item as rebuild, simplify or retire.
Stand up GLPI on supported versions
The platform team installs GLPI on a supported PHP and MariaDB or MySQL combination, checking the current GLPI prerequisites for the release chosen. The web server document root points to GLPI's public directory, with URL rewriting routing requests through index.php. Done means the instance loads over HTTPS in a non-production environment, the database is backed up on a schedule, and the team has written the update procedure into the runbook: back up the database, files and config directory including glpi.key and glpicrypt.key, replace application files, run php bin/console db:update, then reactivate plugins, which GLPI suspends after a new version is detected.
Map tickets, assets and knowledge base articles
Using the exported XML as the source, the team maps Freshservice ticket fields, requesters, groups, assets, relationships and knowledge base articles to GLPI's ticket, asset, user, group and knowledge base objects. Scripted imports should be tested on a copy of the data first. Done means a reconciliation report shows which records loaded, which were rejected and why, and a sample of tickets, assets and articles has been checked by a named reviewer against the source.
Pilot the inventory agent on sample endpoints
The team deploys GLPI Agent to a small, mixed group of Windows, macOS and Linux endpoints and checks the hardware and software records that arrive in GLPI against the device owners' knowledge. The pilot also tests how the agent's records match the asset records migrated from Freshservice, so duplicates are caught early. Done means the pilot group reports correct records for a defined period, and the team has agreed the deployment method for the full estate.
Run Freshservice and GLPI in parallel
For a set period agreed in advance, agents work new requests in GLPI while Freshservice stays available for reference and for requests that started before the switch. Service owners compare SLA reporting, approval routing and asset counts between the two systems. Done means discrepancies are logged, fixed in GLPI and retested, and the service owner signs off on the workflows that carry real operational load.
Cut over and retire Freshservice access
The team sets a cutover date, freezes changes in Freshservice, runs a final delta export and load, redirects the intake channels such as email and the service portal to GLPI, and restricts Freshservice to read-only access for a defined retention period. Done means new requests arrive only in GLPI, the final export is archived, and the handover record lists the owner of each rebuilt workflow and SLA.
Questions buyers ask before switching from Freshservice to GLPI
What does switching from Freshservice to GLPI actually cost?
The software license is not the main cost. GLPI is free under GPL-3.0, so the spend moves to hosting, migration work, configuration of workflows, SLAs and the service catalog, training, and the ongoing admin time to patch and upgrade the platform. Freshservice costs recur per agent and per asset unit pack, while self-hosting costs are mostly one-time for the move and recurring for infrastructure and staff time. Drivers include the number of agents, the volume of assets to import, how many custom workflows you rebuild, and whether you want outside help. Ask any implementation partner for a fixed-scope written quote that lists each deliverable, and ask GLPI Network or a reseller separately if you want paid support.
How long does a Freshservice to GLPI move take?
No fixed duration applies to every team, so treat any published number with caution. The timeline depends on how much data you export, how many tickets and assets you keep, how many workflows, approval chains, SLAs and service catalog items you must rebuild, how many integrations feed the service desk, and how much testing your change process requires. Staff availability and the number of cutover rehearsals also matter. Ask for a written scope with milestones before work starts, and insist that the plan separates data migration, configuration, integration and user acceptance testing so each can be checked.
What does my IT team have to provide during the move?
Your team needs to supply decisions and access more than hands-on effort. Expect to name owners for incident, problem, change and asset processes, provide an export from Freshservice, and confirm which historical tickets and attachments you must keep. You will also need a server or cloud environment you control, database and web server administration skills, identity integration details such as LDAP or SSO settings, and people who can test the workflows. Freshservice administrators can export the full service desk as XML from Admin, Account, Export, and that file is delivered to the registered agent email address, so confirm who holds that mailbox before you start.
Can our team migrate to GLPI without outside help?
A capable team can do it, but the decision depends on skills and capacity rather than on whether GLPI is free. GLPI runs on PHP with MariaDB or MySQL, and its installation docs require the web server's document root to point to the public directory with URL rewriting enabled. Your team must also map Freshservice's conditions, SLAs, service catalog and asset types onto GLPI's model, and test the result. If you lack that experience, a fixed-scope engagement with an implementation partner can cover planning, installation, hardening, data import and documentation. Whichever route you take, ask for a written list of what will be delivered and what remains with your staff.
Does GLPI cover the Freshservice workflows we use today?
GLPI covers the core ITIL areas well: incident, problem, change and service level management, asset inventory, configuration management, knowledge base and contract management. Gaps are more likely in the details, so verify them against your own workflows. Check how GLPI handles your approval chains, automation rules, custom forms, self-service portal design, SLA escalation logic, reporting, and any Freshservice marketplace integrations you rely on. The GLPI Agent collects hardware and software inventory and runs on Windows, macOS and Linux, but compare its discovery output with the asset data you use now. Build a gap list for your team and assign each item a decision: rebuild, change the process, use a plugin, or accept the difference.
How do GLPI upgrades work, and what happens to plugins?
GLPI upgrades follow a documented procedure, and you should plan each one as a change. The installation docs require you to back up the database, the files and the config directory, including the glpi.key and glpicrypt.key files, then replace the application files and run php bin/console db:update. Since GLPI 11.0, plugins are suspended after a new version is detected and must be reactivated, and major updates may need that step again. GLPI 12.0.0 was released on October 7, 2026, and it adds an official Docker image among its distribution options. Confirm your PHP and database versions against the prerequisites before you schedule any upgrade, because the requirements change between major versions.
What does a GLPI Network subscription add over self-hosting?
A GLPI Network subscription adds vendor-backed hosting or support on top of the free software. The published subscriptions page lists GLPI Network public cloud at 19 euros per user per month, 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), which include level 3 support and marketplace plugins. Those figures come from the GLPI Network subscriptions page and may change, so confirm them there. Compare that recurring fee with the staff time and infrastructure you would otherwise carry, and ask the vendor exactly which support levels, response commitments and plugins each tier includes.
Which security controls must we set up on a self-hosted GLPI?
You own the security configuration once GLPI runs in your environment. Start with the authentication method: GLPI tries the internal database, then LDAP directories, IMAP mail servers and other external methods such as REMOTE_USER, in that order, so confirm the order matches your identity policy and disable paths you do not need. Use TLS on the web server, restrict administrative access, protect the key files that the update procedure names, and back up the database and configuration on a schedule you can restore from. GLPI 12.0.0 adds a view of active sessions with the ability to revoke them and step-up authentication for certain administrative actions, which you should enable and test. Document these settings as evidence for your own control reviews, while independent auditors decide whether they meet your requirements.
How DeployOpen helps you evaluate, implement and migrate to GLPI
DeployOpen plans, implements, integrates, hardens, backs up, documents and supports self-hosted open-source platforms inside your own infrastructure. For a Freshservice-to-GLPI move, we start by writing down which Freshservice workflows, asset records and approvals your team relies on, then decide what GLPI should cover in your environment.
How we scope
- We map the Freshservice modules your teams use today, including tickets, changes, problems, assets and the service catalog.
- We confirm GLPI's ITIL modules, inventory agent and CMDB against each mapped need, and record gaps as explicit decisions.
- Engagements are fixed-scope, so deliverables, responsibilities and timelines are agreed in writing before work starts.
How we build
- We deploy GLPI in your own cloud account, data center or air-gapped network, with the database and web tier you have chosen.
- We configure GLPI Agent deployment, authentication sources and ticket categories to match the workflows confirmed during scoping.
- We test imported tickets, assets and knowledge base articles against a sample of Freshservice records before any cutover.
How we hand over
- We document the GLPI configuration, backup procedure, update steps and the rebuilt workflows, SLAs and service catalog.
- We take backups of the database, files and configuration keys, and show your team how to restore them.
- We walk administrators through ticket routing, inventory reporting and plugin reactivation after major updates.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer after handover.
- A retainer can cover GLPI version upgrades, plugin checks and periodic restore tests in your environment.
- Ask us to confirm which GLPI support tier, if any, your team needs, and what each option includes in writing.
