How to Convert a Rust Path to a String

Use Path::to_str() when you need verified UTF-8, Path::to_string_lossy() when readable replacement text is acceptable, and PathBuf::into_string() when you own and can consume a path buffer. If the value must remain an exact operating-system path, keep it as Path/PathBuf or use OsStr/OsString instead of forcing it into a Rust String.

A Rust path is not guaranteed to contain valid UTF-8. That is why conversion APIs make you choose between rejecting invalid Unicode, replacing it for display, or preserving the native representation.

Choose the conversion that matches your goal

Goal	API	Result	Important behavior
Borrow Unicode text and reject invalid paths	`path.to_str()`	`Option<&str>`	Returns `None` when the path is not valid Unicode.
Produce readable text for logs or messages	`path.to_string_lossy()`	`Cow<str>`	Invalid byte sequences become U+FFFD replacement characters.
Consume an owned `PathBuf`	`path_buf.into_string()`	`Result<String, PathBuf>`	On failure, the original `PathBuf` is returned. Stable since Rust 1.98.0.
Preserve the exact native path	`as_os_str()` or `into_os_string()`	`&OsStr` or `OsString`	No Unicode conversion is attempted.
Format a path for output	`path.display()`	`Display` adapter	Convenient and potentially lossy; use `Debug` for escaped output.

The standard library describes to_str() as yielding a string slice only when the path is valid Unicode. See the official Path documentation for the exact API contracts.

Convert a borrowed `&Path` with `to_str()`

to_str() borrows the path and returns an Option<&str>. Handle both variants instead of calling unwrap() unless your application has a documented invariant that every input path is UTF-8.

use std::path::Path;

fn path_text(path: &Path) -> Option<&str> {
    path.to_str()
}

fn main() {
    let path = Path::new("foo.txt");

    match path.to_str() {
        Some(text) => println!("{text}"),
        None => eprintln!("path is not valid Unicode"),
    }
}

This is the right choice for filenames that will become JSON, database text, URLs, or other formats that require valid Unicode. If conversion fails, decide whether to report an input error, skip the item, or use a different representation.

Return an owned `String` without consuming the path

When the caller needs ownership but you still need the original path, convert the borrowed string slice after checking it:

use std::path::Path;

fn owned_path_text(path: &Path) -> Result<String, &'static str> {
    path.to_str()
        .map(str::to_owned)
        .ok_or("path is not valid Unicode")
}

fn main() {
    let path = Path::new("reports/summary.txt");
    let text = owned_path_text(path).expect("expected a UTF-8 path");
    println!("{text}");
}

Use `to_string_lossy()` for readable diagnostics

to_string_lossy() always gives displayable text. It returns a Cow<str>: borrowed text when the path is already valid UTF-8, or an owned string containing U+FFFD for invalid sequences.

use std::path::Path;

fn main() {
    let path = Path::new("foo.txt");
    let text = path.to_string_lossy();
    println!("could not open {text}");
}

Use this for logs, status messages, and human-facing diagnostics where readability matters more than reversibility. The replacement character does not preserve the original bytes, so never use this result as a serialized filename that must later be opened.

Consume a `PathBuf` with `into_string()`

If you own a PathBuf and no longer need it as a path, into_string() avoids borrowing and returns the buffer on failure.

use std::path::PathBuf;

fn main() {
    let path_buf = PathBuf::from("foo.txt");

    match path_buf.into_string() {
        Ok(text) => println!("{text}"),
        Err(original_path) => {
            eprintln!("path is not valid Unicode: {original_path:?}");
        }
    }
}

The current standard-library documentation marks PathBuf::into_string() as stable since Rust 1.98.0. For older compilers, or whenever you must retain the buffer, use checked to_str() followed by to_owned().

Keep the OS-native representation with `OsStr` and `OsString`

Many filesystem APIs accept native strings directly. This avoids an unnecessary and potentially impossible Unicode conversion.

use std::path::{Path, PathBuf};

fn main() {
    let path = Path::new("foo.txt");
    let borrowed_os_str = path.as_os_str();

    let path_buf = PathBuf::from("foo.txt");
    let owned_os_string = path_buf.into_os_string();

    println!("borrowed: {borrowed_os_str:?}");
    println!("owned: {owned_os_string:?}");
}

Use OsStr/OsString when passing a path to filesystem, process, or platform APIs. The OsString documentation explains the checked and lossy conversions available when a boundary really does require Unicode.

Format a path with `display()` or `Debug`

display() is convenient in messages:

use std::path::Path;

fn main() {
    let path = Path::new("logs/app.log");
    println!("reading {}", path.display());
}

The display adapter may be lossy. For escaped output that makes unusual characters visible, use the path’s Debug implementation:

use std::path::Path;

fn main() {
    let path = Path::new("logs/app.log");
    println!("{path:?}");
}

Common patterns for real programs

Reject a non-Unicode path at an API boundary

use std::path::Path;

fn filename_for_json(path: &Path) -> Result<&str, String> {
    path.to_str().ok_or_else(|| {
        format!("path cannot be represented as UTF-8: {path:?}")
    })
}

fn main() {
    let path = Path::new("data/input.csv");
    let value = filename_for_json(path).expect("valid UTF-8 required");
    println!("{value}");
}

Log every path without failing the operation

use std::path::Path;

fn log_path(path: &Path) {
    eprintln!("processing {}", path.to_string_lossy());
}

fn main() {
    log_path(Path::new("uploads/photo.jpg"));
}

Convert a collection while preserving errors

use std::path::PathBuf;

fn all_unicode(paths: Vec<PathBuf>) -> Result<Vec<String>, PathBuf> {
    paths
        .into_iter()
        .map(|path| path.into_string())
        .collect()
}

fn main() {
    let paths = vec![PathBuf::from("a.txt"), PathBuf::from("b.txt")];
    let names = all_unicode(paths).expect("all paths must be Unicode");
    println!("{names:?}");
}

Platform and edge cases

Non-UTF-8 Unix paths: Unix permits arbitrary byte sequences other than NUL and slash in filenames. Such a path can make to_str() return None.
Windows native strings: Windows paths are represented through platform-native wide strings. They can still contain values that do not fit your required text format, so check conversion results.
Empty paths: An empty Path can convert successfully to an empty string. Decide whether that is valid for your application.
Separators: A path is not a URL. Do not replace separators or concatenate strings when you need path semantics; use PathBuf::push and related methods.
Lifetime: A &str returned by to_str() cannot outlive the borrowed Path. Call to_owned() when data must outlive it.
Round trips: A lossy string cannot reliably be converted back to the original path. Keep the original PathBuf when round-trip identity matters.

Troubleshooting

Symptom	Cause	Fix
`expected &str, found Option<&str>`	`to_str()` is fallible.	Match on `Some`/`None`, use `ok_or`, or choose a deliberate lossy policy.
Program panics at `to_str().unwrap()`	The path is not valid UTF-8.	Remove the unconditional unwrap and report or preserve the native path.
Logs contain �	`to_string_lossy()` replaced invalid sequences with U+FFFD.	Keep the original path for machine use; use `Debug` when escaped diagnostics are needed.
`into_string` is unavailable	The compiler predates its Rust 1.98.0 stabilization.	Use `path_buf.to_str().map(str::to_owned)` and handle `None`.
A converted path cannot be opened	Text conversion changed separators, encoding, or invalid bytes.	Pass `Path`/`PathBuf` or `OsStr` to the filesystem API instead of converting.
Output is hard to read	`Debug` escapes characters, while lossy display may replace them.	Choose `display()` for ordinary messages and `Debug` for diagnostic fidelity.

Performance, reliability, and compatibility

Borrow when possible: to_str() and as_os_str() avoid allocation on success because they return views into the path.
Expect allocation when owning text: to_owned() creates a String; lossy conversion allocates only when replacement is needed.
Do not convert in tight filesystem loops unless required: pass paths directly to APIs that accept them.
Make the Unicode policy explicit: rejecting invalid paths is safer for machine protocols; lossy text is appropriate for diagnostics.
Compiler support: use into_string() only with Rust 1.98.0 or later; the checked borrowed pattern works for older toolchains.

Or skip the browser setup

If your Rust program ultimately needs screenshots of URLs rather than local filesystem paths, ScreenshotNeo provides a single HTTP request. It removes cookie banners, popups, and chat widgets before capture; bot checks, blank pages, timeouts, failed loads, and cache hits are not billed. Its MCP server lets AI agents take screenshots, and the free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. See the ScreenshotNeo API documentation for options.

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode url=https://stripe.com \
  -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());

Create a free ScreenshotNeo account to get 1,000 screenshots each month with no card.

FAQ

Should I always use `to_string_lossy()`?

No. It is suitable for readable diagnostics, not for data that must round-trip exactly.

Does `Path` always contain UTF-8?

No. Rust’s path types support operating-system representations that may not be valid UTF-8.

How do I get a `String` from a borrowed path?

Call to_str(), handle None, then call to_owned() or to_string() on the returned slice.

When should I use `OsString`?

Use it when the consumer is a filesystem or platform API and Unicode text is not a requirement.

Is `display()` lossless?

No. The display adapter is intended for formatting and may be lossy; use the path itself for machine operations.

For API details, consult the Rust documentation for Path, PathBuf, and OsString.

Choose the conversion that matches your goal

Convert a borrowed &Path with to_str()

Return an owned String without consuming the path

Use to_string_lossy() for readable diagnostics

Consume a PathBuf with into_string()

Keep the OS-native representation with OsStr and OsString

Format a path with display() or Debug

Common patterns for real programs

Reject a non-Unicode path at an API boundary

Log every path without failing the operation

Convert a collection while preserving errors

Platform and edge cases

Troubleshooting

Performance, reliability, and compatibility

Or skip the browser setup

FAQ

Should I always use to_string_lossy()?

Does Path always contain UTF-8?

How do I get a String from a borrowed path?

When should I use OsString?

Is display() lossless?

Keep reading

Excel MCP Server for Windows: Setup, Choices, and Troubleshooting

LinkedIn Open to Work Image

BrowserStack Test Management Tool: Features, Integrations, Migration and Practical Guide