Chrome Enterprise Printing Settings (2026)

Last updated: April 17, 2026

Chrome Enterprise printing settings provide granular control over how Chrome handles print jobs in organizational environments. Whether you’re managing a fleet of devices or building applications that integrate with Chrome’s printing subsystem, understanding these settings helps you optimize workflows and reduce support overhead.

This guide covers the key Chrome policies related to printing, practical configuration methods, and code examples for automating print settings at scale.

Understanding Chrome Print Policies

Chrome implements printing controls through enterprise policies defined in JSON configuration files. These policies control everything from default printer selection to PDF handling and print preview behavior. The policy system is hierarchical: machine-level policies override user-level policies, and cloud policies can override locally applied ones if you use Google Workspace.

The primary policies you’ll encounter include:

DefaultPrinterSelection. Specifies which printer Chrome selects by default
PrintPreviewDisabled. Disables the print preview dialog entirely
PrintingEnabled. Enables or disables printing functionality
PrintHeaderFooter. Controls whether headers and footers appear on printed pages
PrintingPaperSizeDefault. Sets the default paper size
PrintingColorDefault. Controls whether the default is color or monochrome
PrintingDuplexDefault. Sets default duplex/simplex behavior
PrintingMaxSheetsAllowed. Limits the number of sheets per print job
PrintingBackgroundGraphicsDefault. Controls whether background images and colors print
CloudPrintProxyEnabled. Enables or disables the legacy Google Cloud Print proxy

You can view the complete list of printing-related policies in the Chrome Enterprise Policy List.

Policy Scope: Machine vs. User Level

Before deploying printing policies, understand where Chrome looks for them. Policies set at the machine level apply to all users on the device. User-level policies apply only to logged-in managed accounts.

Policy Scope	Windows Location	macOS Location	Linux Location
Machine	`HKLM\Software\Policies\Google\Chrome`	`/Library/Managed Preferences/com.google.Chrome.plist`	`/etc/opt/chrome/policies/managed/`
User	`HKCU\Software\Policies\Google\Chrome`	`~/Library/Preferences/com.google.Chrome.plist`	`~/.config/google-chrome/policies/`
Recommended	`HKLM\...\Recommended`	`/Library/Managed Preferences/recommended/`	`/etc/opt/chrome/policies/recommended/`

The “Recommended” scope is worth calling out separately. Policies placed there appear as defaults in Chrome settings but allow users to override them. This is useful for printing scenarios where you want to suggest a default printer but let users pick their own when needed.

Configuring Policies via JSON

Chrome reads enterprise policies from JSON files stored in specific locations depending on your operating system. On Windows, this typically lives in the Windows Registry or a JSON file in the program data directory. On macOS and Linux, JSON files in /etc/opt/chrome/policies/ or /etc/chromium/policies/ control the settings.

Here’s an example JSON configuration that sets default printing behavior:

{
 "DefaultPrinterSelection": {
 "printerName": "CorpNet-Printer-Floor3",
 "deviceName": "CN=CorpNet-Printer-Floor3"
 },
 "PrintHeaderFooter": false,
 "PrintingPaperSizeDefault": "A4",
 "PrintingEnabled": true,
 "PrintPreviewDisabled": false,
 "PrintingColorDefault": "monochrome",
 "PrintingDuplexDefault": "long-edge",
 "PrintingMaxSheetsAllowed": 100
}

For developers automating Chrome installations, you can deploy this configuration alongside your Chrome setup script or through group policy objects (GPO) in Active Directory environments.

Deploying Policies at Scale with Ansible

If you manage dozens or hundreds of machines, a configuration management tool makes deployment repeatable. Here is an Ansible task that drops a printing policy file onto Linux workstations:

- name: Create Chrome managed policies directory
 file:
 path: /etc/opt/chrome/policies/managed
 state: directory
 owner: root
 group: root
 mode: '0755'
- name: Deploy Chrome printing policy
 copy:
 dest: /etc/opt/chrome/policies/managed/printing.json
 owner: root
 group: root
 mode: '0644'
 content: |
 {
 "PrintingEnabled": true,
 "PrintHeaderFooter": false,
 "PrintingColorDefault": "monochrome",
 "PrintingDuplexDefault": "long-edge",
 "PrintingPaperSizeDefault": "A4"
 }

After the task runs, any running Chrome instance picks up the changes when the user navigates to chrome://policy and clicks “Reload policies”, or when Chrome performs its next automatic policy refresh (typically every 3 hours).

Managing Printers Programmatically

When building internal tools that interact with Chrome printing, you might need to query available printers or set default printers dynamically. Chrome exposes print preview functionality through the chrome.printing API, but this requires appropriate permissions in your extension or application.

Here’s how you might query available printers using the Chrome Printing API in an extension context:

chrome.printing.getPrinters((printers) => {
 const corpPrinters = printers.filter(p =>
 p.name.startsWith('CorpNet-')
 );
 console.log('Available corporate printers:', corpPrinters);
 if (corpPrinters.length > 0) {
 // Set the first matching printer as default
 chrome.printing.setDefaultPrinter(corpPrinters[0].id);
 }
});

Note that the chrome.printing API requires the printing permission in your manifest and only works in Chrome Enterprise or Chrome Education editions.

Submitting a Print Job Programmatically

Beyond querying printers, you can submit jobs directly from an extension. This is useful for kiosk applications or internal tools where print behavior must be entirely scripted:

async function printDocumentToPDF(pdfBytes) {
 const printers = await chrome.printing.getPrinters();
 const target = printers.find(p => p.name === 'CorpNet-Printer-Floor3');
 if (!target) {
 console.error('Target printer not found');
 return;
 }
 const ticket = {
 version: '1.0',
 print: {
 color: { type: 'STANDARD_MONOCHROME' },
 duplex: { type: 'LONG_EDGE' },
 page_orientation: { type: 'PORTRAIT' },
 copies: { copies: 1 },
 dpi: { horizontal_dpi: 600, vertical_dpi: 600 },
 media_size: {
 width_microns: 210000,
 height_microns: 297000,
 is_default: true
 },
 collate: { collate: true }
 }
 };
 const jobId = await chrome.printing.submitJob({
 printerId: target.id,
 title: 'Auto Print Job',
 ticket: ticket,
 document: new Blob([pdfBytes], { type: 'application/pdf' })
 });
 console.log('Submitted job:', jobId);
}

The submitJob call returns a job ID that you can use with chrome.printing.cancelJob if you need to programmatically abort a stuck print request.

Printer-Specific Settings via PPD Files

For Unix/Linux environments managing CUPS (Common UNIX Printing System), you can specify printer-specific settings through PPD (PostScript Printer Description) files. Chrome passes these settings through to the print backend.

A minimal PPD configuration for a network printer might look like:

*PPD-Adobe: "4.3"
*FormatVersion: "4.3"
*FileVersion: "1.0"
*LanguageVersion: English
*Product: "CorpNet LaserJet Pro"
*ModelName: "HP LaserJet Pro M404n"
*DefaultOutputBin: Main
*DefaultPageSize: A4
*DefaultResolution: 600dpi

Chrome reads these PPD files when initializing the print subsystem, making them essential for controlling page margins, color modes, and duplex settings.

When CUPS receives a print job from Chrome, it looks up the PPD for the destination printer and uses those capabilities to translate Chrome’s abstract job ticket into the correct PostScript or PCL. If your printer supports capabilities not listed in its PPD, Chrome will not offer them in the print preview, even if the hardware supports them. Updating or replacing PPD files is often the fastest way to unlock missing print options.

Enterprise Print Servers and Chrome

Large organizations typically deploy print servers that handle print job routing, authentication, and accounting. Chrome can integrate with these servers through standard protocols like IPP (Internet Printing Protocol) or SMB/CIFS.

For IPP-based print servers, configure the connection in Chrome by navigating to chrome://settings/printers or by pushing the configuration via policy:

{
 "ExternalPrintServers": {
 "Allow": true,
 "BlockList": [],
 "AllowList": ["printserver.corp.internal"]
 }
}

This configuration allows Chrome to connect to specified print servers while maintaining security boundaries. The AllowList parameter restricts connections to trusted servers only.

IPP Everywhere and Driverless Printing

Modern Chrome Enterprise deployments can take advantage of IPP Everywhere, which eliminates the need for printer-specific drivers. Chrome communicates directly with IPP Everywhere-compliant printers using a standardized protocol. To verify your printer supports this:

Check if printer advertises IPP Everywhere support
ipptool -tv ipp://printserver.corp.internal/printers/floor3 get-printer-attributes.test | grep "document-format"

If the output includes application/pdf and image/pwg-raster, the printer supports driverless printing. In this case you can add it to Chrome without installing any driver at all, which simplifies rollout significantly.

Print Job Management and Monitoring

Chrome records print job history locally, which can be useful for debugging or auditing. You can access this data through the chrome.printingMetrics API:

chrome.printingMetrics.getPrintJobs((jobs) => {
 jobs.forEach(job => {
 console.log(`Job ${job.id}: ${job.title} - ${job.status}`);
 console.log(` Printed on: ${new Date(job.creationTime)}`);
 console.log(` Pages: ${job.totalPageCount}`);
 });
});

This API provides visibility into print volumes and can help you identify excessive printing or troubleshoot failed jobs.

Aggregating Metrics Across a Fleet

For IT teams that need fleet-wide print auditing, a background service worker can periodically collect and forward these metrics to a central endpoint:

// background.js in a managed extension
const REPORT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
async function reportPrintMetrics() {
 const jobs = await new Promise(resolve =>
 chrome.printingMetrics.getPrintJobs(resolve)
 );
 const report = {
 timestamp: Date.now(),
 deviceId: await getDeviceId(),
 totalJobs: jobs.length,
 totalPages: jobs.reduce((sum, j) => sum + j.totalPageCount, 0),
 failedJobs: jobs.filter(j => j.status === 'FAILED').length
 };
 await fetch('https://metrics.corp.internal/print-report', {
 method: 'POST',
 headers: { 'Content-Type': 'application/json' },
 body: JSON.stringify(report)
 });
}
setInterval(reportPrintMetrics, REPORT_INTERVAL_MS);

This pattern works well when the extension is distributed as a force-installed managed extension, ensuring every enrolled device reports back without user interaction.

Common Configuration Scenarios

Scenario 1: Lock down printing in kiosk mode

{
 "PrintingEnabled": false,
 "PrintPreviewDisabled": true
}

Scenario 2: Enforce color printing for specific departments

{
 "PrintingColorDefault": "color",
 "PrinterAccessMode": "authorized"
}

Scenario 3: Redirect all prints to PDF

{
 "DefaultPrinterSelection": {
 "printerName": "Save as PDF",
 "id": "Save as PDF"
 }
}

Scenario 4: Enforce black-and-white and duplex globally to reduce costs

{
 "PrintingColorDefault": "monochrome",
 "PrintingDuplexDefault": "long-edge",
 "PrintingMaxSheetsAllowed": 50
}

This combination alone can meaningfully cut consumable costs across a large office by defaulting every print job to two-sided monochrome and capping runaway print jobs at 50 sheets. Users can still override these defaults in the print preview dialog unless you pair this with PrintPreviewDisabled: true.

Scenario 5: Prevent background graphics from printing (improves readability and saves ink)

{
 "PrintingBackgroundGraphicsDefault": "disabled"
}

Troubleshooting Tips

When Chrome printing misbehaves, check these common issues:

Policy conflicts. Multiple policy sources can conflict. Use chrome://policy to view applied policies
Extension interference. Some Chrome extensions modify print behavior. Test in incognito mode
Print spooler issues. Chrome relies on the OS print spooler; restart the service if jobs hang
Driver compatibility. Ensure printer drivers match Chrome’s architecture (32-bit vs 64-bit)
CUPS misconfiguration. On Linux, run cupsd -t to validate the CUPS config file before restarting the daemon
IPP firewall rules. IPP uses port 631 over TCP. Ensure firewalls allow this traffic between workstations and print servers

You can force Chrome to reload policies without restarting by navigating to chrome://policy and clicking “Reload policies”.

For more detailed diagnostics, Chrome writes print-related events to the system log. On Linux, you can tail CUPS logs directly:

Tail CUPS error log for real-time print debugging
sudo tail -f /var/log/cups/error_log

Cross-reference entries in the CUPS log against the job IDs returned by chrome.printingMetrics.getPrintJobs to pinpoint exactly where a job fails in the pipeline.

Wrapping Up

Chrome Enterprise printing settings offer the control that organizations need to manage printing at scale. By using JSON policy files, the Chrome printing APIs, and proper print server configuration, you can create predictable, auditable printing workflows across your entire deployment.

Whether you’re scripting automated setups, building internal tooling, or reducing print costs through sensible defaults, these configuration options provide the foundation for reliable enterprise printing. Start by deploying a baseline policy that sets paper size and duplex defaults, then layer on more specific controls as you identify problems in your environment.

This took me 3 hours to figure out. I put it in a CLAUDE.md so I'd never figure it out again. Now Claude gets it right on the first try, every project. 16 framework templates. Next.js, FastAPI, Laravel, Rails, Go, Rust, Terraform, and 9 more. Each one 300+ lines of "here's exactly how this stack works." Copy into your project. Done. **[See the templates →](https://zovo.one/lifetime?utm_source=ccg&utm_medium=cta-config&utm_campaign=chrome-enterprise-printing-settings)** $99 once. Yours forever. I keep adding templates monthly.