Can you hide an activity's execution in UiPath logs using the Private Property?

Yes. You can control log visibility by setting the Private Property on individual activities, which prevents their execution details from appearing in logs. This is more precise than global log levels and helps protect sensitive steps without affecting other parts of the workflow.

If you’re building intricate automation workflows in UiPath, you’ve probably peeked at the logs and thought, “There’s a lot of noise here.” Logs are the breadcrumbs that help you trace what happened, when it happened, and in some cases, why it happened. But there are times when you want to hide certain details—either because they contain sensitive data or because the activity simply isn’t relevant to an audit trail. The good news is: yes, you can control the visibility of an activity’s execution in the logs. And the mechanism is elegant enough that it feels almost built for real-world scenarios where confidentiality matters.

Let’s get into the practical side of things and keep the jargon light, so you can apply this without getting tangled in tangled-up configurations.

A quiet detail: the Private Property

The core concept is surprisingly simple: many UiPath activities expose a property called Private. When you set this property to true, the activity’s execution details don’t show up in the logs. It’s a targeted, per-activity control, which means you don’t have to blanket-hide everything or rewrite your logging strategy to keep certain data out of sight. It’s like placing a privacy screen in front of a camera—the moment you flip the switch, you’ve blocked the view of that particular moment.

Here’s the mental model you can use: logging is about visibility, and the Private property is about selective visibility. You don’t need to disable all logging or redesign your entire process to protect sensitive data. You simply mark the sensitive activities as private, and UiPath respects that choice.

Where to find and how to set it

If you’re new to this, the path is straightforward:

• Open your workflow and locate the activity you want to mask in the logs.

• In the Properties pane, look for a property named Private.

• Set Private = True.

That’s it. In the next run, you’ll notice that the activity doesn’t print its name, input arguments, or the details of its execution in the standard logs. You’ll still see higher-level process flow messages—things like when a sequence starts or finishes, or when an overall workflow completes. The goal is to keep the footprint of that single activity out of sight while preserving the rest of the story in the log.

A quick note on scope and behavior

Two points to keep in mind:

• Scope is per-activity. If you have a long chain of steps and only one of them is sensitive, you’ll mark just that one as Private. You don’t need to touch siblings or downstream steps.

• There’s a balance to strike. If an activity is private, you won’t be able to troubleshoot it directly in the logs. If you need to audit what happened inside that activity, you’ll have to rely on alternate methods (for example, external monitoring, separate trace data, or protected screen outputs) outside of the standard logs.

Why not global log-level changes?

You might wonder whether tweaking a global logging setting could help you achieve the same outcome. It won’t. Adjusting a global log level (think of it as raising or lowering the overall verbosity of the entire process) affects all activities uniformly. It’s a blunt instrument. The Private property is the precise tool you want when the goal is selective visibility. It’s the difference between turning down the volume on the whole orchestra and muting just one instrument when it’s playing a sensitive solo.

Common misconceptions—and why they miss the mark

• “Logs cannot be modified.” Not true, as you’ve seen. You can tailor what gets recorded on a fine-grained level using properties like Private. It’s about selective visibility, not about locking logging altogether.

• “You can only hide logs for certain activities by design.” The Private flag is exactly designed for that scenario. It doesn’t blanket-hide everything; it quietly scratches out the parts you don’t want to reveal.

• “Only security folks care about this.” Security and governance touch every automation project. Even a small privacy win—like masking a password, a token, or PII—reduces risk and makes audits smoother.

Real-world scenarios that make sense

• Handling credentials securely. If you’re calling a sub-process that uses a password, you might not want the raw password or the exact authentication steps to appear in logs. Mark the sensitive activity as Private, and you keep the process readable while protecting critical data.

• Proprietary business logic. Some steps encapsulate unique methods or trade secrets. Hiding their internals in logs can help shield that information from casual inspection while preserving operational transparency elsewhere.

• Compliance with data handling rules. In regulated environments, you often need to ensure logs don’t expose sensitive information. The Private flag gives you a straightforward way to comply without rewriting your entire logging strategy.

A quick tour through common myths

• “Private means no logs at all.” Not so. It means the activity’s internal details are hidden, not the entire process. You’ll still get a high-level trace of the workflow’s progression.

• “This ruins debugging.” It can feel slightly inconvenient at first, but it’s a small trade-off for protecting sensitive data. When you need deeper debugging, you can temporarily remove the Private flag or use alternative tracing mechanisms just for the debugging window.

• “It’s only for security teams.” It’s beneficial for any scenario where data privacy and operational confidentiality matter, which is almost any real-world automation project these days.

Analogies to keep the idea grounded

Think of logging like a diary for your automation. Some pages are about everyday events—when a task started, when it finished, the broad steps taken. Other pages might contain personal notes, passwords, or strategic secrets you don’t want shared beyond a trusted circle. The Private property is your ability to blur out those sensitive pages while leaving the rest of the diary intact.

If you’re into analogies, you can imagine it as a camera with privacy lenses. You can still capture the scene, but you’ve blacked out the frames that matter only to people who shouldn’t see them. It’s practical, it’s clean, and it keeps the story coherent.

Tips for keeping your logging well-behaved

• Plan from the start. Consider which activities will need privacy and mark them accordingly as you design the workflow. A little forethought goes a long way.

• Use comments and documentation. Since the logs are partially obfuscated, keep external documentation that explains why certain steps are private. This helps teammates understand the architecture without needing to scrabble through private logs.

• Test with privacy enabled. Run a few iterations with Private set to true to verify that the log output is what you expect. It’s easy to miss a trace line if you’re not mindful of what’s being hidden.

• Pair privacy with secure storage. If you’re masking inputs or outputs, make sure any essential audit data is preserved in a secure, separate channel if compliance requires it.

A note on the broader logging ecosystem

In UiPath, you’re operating within a broader logging and monitoring ecosystem. This means there are other knobs and levers—like log messages emitted by activities, or custom logging introduced via write-log messages. The Private property sits cleanly at the activity level, but you can complement it with thoughtful log message design. For instance, you can log the start and end of a process at a high level, while letting private activities do their work unseen in the logs. It’s a balanced approach that keeps visibility where it’s most valuable and privacy where it’s most needed.

Bringing it together

So, yes, you can manage log visibility with precision. The Private property serves as a precise dial you can twist to hide the details of a chosen activity’s execution. This isn’t about disabling logs or throwing away the mechanism that helps you understand workflows; it’s about applying discretion where it’s warranted. It’s a small but meaningful feature that mirrors real-world needs: some things are fine to share, others deserve a quiet, closed-door treatment.

If you’re exploring or refining your UiPath projects, give the Private flag a try on the sensitive activities. You’ll likely notice the logs become more approachable, not noisier, and you’ll gain a useful layer of confidentiality without sacrificing the overall traceability of your automation journey. And when you need visibility again, you can flip the switch back or compartmentalize your debugging efforts with a mix of private and non-private activities. The beauty is in the control—and that control, in practice, is surprisingly intuitive.