> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/sinelaw/fresh/llms.txt
> Use this file to discover all available pages before exploring further.

# Privacy & Telemetry

> What data Fresh collects and how to disable telemetry

Fresh respects your privacy. This page explains what data is collected, why, and how to disable it.

## What Fresh Collects

Fresh checks for new versions to notify you when upgrades are available. Alongside this check, it sends basic anonymous telemetry to help understand usage patterns.

### Data Collected

The data collected includes:

<AccordionGroup>
  <Accordion title="Fresh Version">
    The version of Fresh you're running (e.g., `1.0.0`).

    **Purpose**: Track which versions are in use to prioritize support and bug fixes.
  </Accordion>

  <Accordion title="Operating System and Architecture">
    Your OS and CPU architecture (e.g., `linux-x86_64`, `macos-aarch64`, `windows-x86_64`).

    **Purpose**: Understand platform distribution to focus development and testing efforts.
  </Accordion>

  <Accordion title="Terminal Type">
    The `TERM` environment variable value (e.g., `xterm-256color`, `screen`, `tmux-256color`).

    **Purpose**: Identify terminal compatibility issues and improve rendering support.
  </Accordion>
</AccordionGroup>

### What Is NOT Collected

<Warning>
  Fresh does **NOT** collect:

  * Personal information (name, email, IP address, etc.)
  * File contents or file names
  * Keyboard input or editing behavior
  * Project or directory names
  * Configuration details
  * Plugin usage
  * Any personally identifiable information (PII)
</Warning>

## When Checks Occur

Upgrade checks and telemetry are sent:

1. **Once on startup** when you launch Fresh
2. **Once daily** while Fresh is running

No data is sent:

* While you're editing
* When Fresh is idle
* Continuously in the background

<Note>
  The check is performed asynchronously and does not block the editor or impact performance.
</Note>

## Disabling Telemetry

You can disable both upgrade checking and telemetry together. There are two methods:

### Method 1: Command-Line Flag

Disable for a single session:

```bash theme={null}
fresh --no-upgrade-check
```

This flag disables both upgrade checks and telemetry for that run of Fresh.

### Method 2: Configuration File

Disable permanently by editing `~/.config/fresh/config.json`:

```json theme={null}
{
  "check_for_updates": false
}
```

Save the file and restart Fresh. Telemetry and upgrade checks will be disabled.

<Accordion title="Verify Configuration">
  You can verify the setting is applied:

  ```bash theme={null}
  fresh --cmd config show | grep check_for_updates
  ```

  Should output:

  ```json theme={null}
  "check_for_updates": false
  ```
</Accordion>

## Why Telemetry?

Telemetry helps the Fresh maintainers:

* **Prioritize platforms**: Focus development on the most-used OS/architecture combinations
* **Improve terminal support**: Identify which terminal emulators need better compatibility
* **Measure adoption**: Understand how quickly users upgrade to new versions
* **Validate releases**: Confirm new versions are being successfully deployed

<Note>
  Telemetry is completely optional and can be disabled at any time. Fresh works perfectly fine without it.
</Note>

## Transparency

Fresh's telemetry implementation is open source. You can review the code:

* **Telemetry code**: Check `crates/fresh-editor/src/services/release_checker.rs` in the [Fresh repository](https://github.com/sinelaw/fresh)
* **What's sent**: All telemetry data is included in the upgrade check HTTP request
* **No tracking**: There are no analytics IDs, cookies, or persistent tracking

## Network Requests

When telemetry is enabled, Fresh makes HTTP requests to:

* **Purpose**: Check for new releases and send telemetry
* **Frequency**: Once on startup, then once per day
* **Protocol**: HTTPS (encrypted)
* **Response**: Returns information about the latest Fresh release

<Warning>
  If you're on a corporate or restricted network, these requests may be blocked by your firewall. This is harmless - Fresh will continue working normally.
</Warning>

## Offline Usage

Fresh works completely offline:

* No internet connection required for editing
* Telemetry gracefully fails if offline
* LSP and plugins work locally (unless they require network access)

## Privacy-Focused Alternatives

If you want to stay informed about updates without telemetry:

1. **Watch the GitHub repository**: Get notifications for new releases
2. **Check manually**: Run `fresh --version` and compare with the [releases page](https://github.com/sinelaw/fresh/releases)
3. **Subscribe to announcements**: Follow the project's communication channels

## Examples

<CodeGroup>
  ```bash Disable for single session theme={null}
  fresh --no-upgrade-check file.txt
  ```

  ```bash Disable permanently (config) theme={null}
  # Edit ~/.config/fresh/config.json
  {
    "check_for_updates": false
  }
  ```

  ```bash Verify setting theme={null}
  fresh --cmd config show | grep check_for_updates
  ```

  ```bash Check version manually theme={null}
  fresh --version
  ```
</CodeGroup>

## Comparison with Other Editors

| Editor        | Telemetry Default | Opt-out Method                |
| ------------- | ----------------- | ----------------------------- |
| Fresh         | Enabled           | Single flag or config setting |
| VS Code       | Enabled           | Multiple settings to disable  |
| IntelliJ IDEA | Enabled           | Multiple dialogs and settings |
| Vim/Neovim    | None              | N/A                           |
| Emacs         | None              | N/A                           |

Fresh's telemetry is:

* **Minimal**: Only 3 data points
* **Anonymous**: No personal information
* **Easy to disable**: Single flag or config option
* **Transparent**: Open source implementation

## FAQ

<AccordionGroup>
  <Accordion title="Does disabling telemetry affect functionality?">
    No. Fresh works exactly the same with or without telemetry. You only miss notifications about new releases.
  </Accordion>

  <Accordion title="Can I disable just telemetry but keep update checks?">
    No. The update check and telemetry are sent in the same HTTP request. Disabling one disables both.
  </Accordion>

  <Accordion title="Is my IP address logged?">
    Fresh does not log IP addresses. Your IP may appear in standard web server logs (like any HTTP request), but it's not stored or associated with telemetry data.
  </Accordion>

  <Accordion title="Can you track individual users?">
    No. There are no user IDs, session IDs, or any form of persistent tracking. Each telemetry ping is completely anonymous.
  </Accordion>

  <Accordion title="Does Fresh use analytics services like Google Analytics?">
    No. Fresh does not use any third-party analytics services. All requests go directly to Fresh's update server.
  </Accordion>

  <Accordion title="What if I'm behind a firewall?">
    If telemetry requests are blocked, Fresh will fail silently and continue working normally. No errors or warnings are shown.
  </Accordion>
</AccordionGroup>

## Contact

If you have questions or concerns about privacy:

* **GitHub Issues**: [Open an issue](https://github.com/sinelaw/fresh/issues)
* **Documentation**: This page and the [troubleshooting guide](/reference/troubleshooting)

## See Also

* [CLI Commands](/reference/cli-commands) - Using `--no-upgrade-check` flag
* [Configuration](/configuration/overview) - Config file format
* [Troubleshooting](/reference/troubleshooting) - Network and connectivity issues