diff --git a/website_and_docs/content/documentation/grid/advanced_features/_index.pt-br.md b/website_and_docs/content/documentation/grid/advanced_features/_index.pt-br.md
index ae4c1b30844..e9a4d28b76b 100644
--- a/website_and_docs/content/documentation/grid/advanced_features/_index.pt-br.md
+++ b/website_and_docs/content/documentation/grid/advanced_features/_index.pt-br.md
@@ -1,18 +1,9 @@
 ---
-title: "Advanced Features"
-linkTitle: "Advanced Features"
+title: "Características avançadas"
+linkTitle: "Características avançadas"
 weight: 12
 description: >
-  To get all the details of the advanced features, understand how it works, and how to set
-  up your own, please browse thorough the following sections.
+  Para obter todos os detalhes dos recursos avançados, entenda como funciona e como configurar
+  crie o seu próprio, navegue pelas seções a seguir.
 aliases: ["/documentation/pt-br/grid/grid_4/advanced_features/"]
 ---
-
-{{% pageinfo color="warning" %}}
-<p class="lead">
-   <i class="fas fa-language d-4"></i> 
-   Page being translated from 
-   English to Portuguese. Do you speak Portuguese? Help us to translate
-   it by sending us pull requests!
-</p>
-{{% /pageinfo %}}
diff --git a/website_and_docs/content/documentation/grid/advanced_features/customize_node.pt-br.md b/website_and_docs/content/documentation/grid/advanced_features/customize_node.pt-br.md
index 21b4e4a4fad..f2a4a605824 100644
--- a/website_and_docs/content/documentation/grid/advanced_features/customize_node.pt-br.md
+++ b/website_and_docs/content/documentation/grid/advanced_features/customize_node.pt-br.md
@@ -1,70 +1,60 @@
 ---
-title: "Customizing a Node"
-linkTitle: "Customize Node"
+title: "Personalizando um Nó"
+linkTitle: "Personalizando um Nó"
 weight: 4
 ---
+## Como personalizar um Nó
 
-{{% pageinfo color="warning" %}}
-<p class="lead">
-   <i class="fas fa-language d-4"></i> 
-   Page being translated from 
-   English to Portugese. Do you speak Portugese? Help us to translate
-   it by sending us pull requests!
-</p>
-{{% /pageinfo %}}
+Há momentos em que gostaríamos de personalizar um Nó de acordo com nossas necessidades.
 
-## How to customize a Node
+Por exemplo, podemos desejar fazer alguma configuração adicional antes que uma sessão comece a ser executada e executar alguma limpeza após o término de uma sessão.
 
-There are times when we would like a Node to be customized to our needs. 
+Os seguintes passos podem ser seguidos para isso:
 
-For e.g., we may like to do some additional setup before a session begins execution and some clean-up after a session runs to completion.
-
-Following steps can be followed for this:
-
-* Create a class that extends `org.openqa.selenium.grid.node.Node`
-* Add a static method (this will be our factory method) to the newly created class whose signature looks like this: 
+- Crie uma classe que estenda `org.openqa.selenium.grid.node.Node`.
+- Adicione um método estático (este será nosso método de fábrica) à classe recém-criada, cuja assinatura se parece com esta:
 
   `public static Node create(Config config)`. Here:
 
-    * `Node` is of type `org.openqa.selenium.grid.node.Node`
-    * `Config` is of type `org.openqa.selenium.grid.config.Config`
-* Within this factory method, include logic for creating your new Class.
-* To wire in this new customized logic into the hub, start the node and pass in the fully qualified class name of the above class to the argument `--node-implementation`
+    * `Node` é do tipo `org.openqa.selenium.grid.node.Node`
+    * `Config` é do tipo `org.openqa.selenium.grid.config.Config`
+* Dentro deste método de fábrica, inclua a lógica para criar sua nova classe..
+* TPara incorporar esta nova lógica personalizada no hub, inicie o nó e passe o nome da classe totalmente qualificado da classe acima como argumento. `--node-implementation`
 
-Let's see an example of all this:
+Vamos ver um exemplo de tudo isso:
 
-### Custom Node as an uber jar
+### Node personalizado como um uber jar
 
-1. Create a sample project using your favourite build tool (**Maven**|**Gradle**).
-2. Add the below dependency to your sample project.
+1. Crie um projeto de exemplo usando sua ferramenta de construção favorita. (**Maven**|**Gradle**).
+2. Adicione a seguinte dependência ao seu projeto de exemplo..
     * [org.seleniumhq.selenium/selenium-grid](https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-grid)
-3. Add your customized Node to the project.
-4. Build an [uber jar](https://imagej.net/develop/uber-jars) to be able to start the Node using `java -jar` command.
-5. Now start the Node using the command:
+3. Adicione o seu nó personalizado ao projeto.
+4. Construir algo. [uber jar](https://imagej.net/develop/uber-jars) Para ser capaz de iniciar o Node usando o comando `java -jar`.
+5. Agora inicie o nó usando o comando:
 
 ```bash
 java -jar custom_node-server.jar node \
 --node-implementation org.seleniumhq.samples.DecoratedLoggingNode
 ```
+**Observação:** Se estiver usando o Maven como ferramenta de construção, é preferível usar o [maven-shade-plugin](https://maven.apache.org/plugins/maven-shade-plugin) em vez do [maven-assembly-plugin](https://maven.apache.org/plugins/maven-assembly-plugin) porque o plugin maven-assembly parece ter problemas para mesclar vários arquivos de Service Provider Interface (`META-INF/services`).
 
-**Note:** If you are using Maven as a build tool, please prefer using [maven-shade-plugin](https://maven.apache.org/plugins/maven-shade-plugin) instead of [maven-assembly-plugin](https://maven.apache.org/plugins/maven-assembly-plugin) because maven-assembly plugin seems to have issues with being able to merge multiple Service Provider Interface files (`META-INF/services`)
 
-### Custom Node as a regular jar
+### Node personalizado como jar
+
+1. Crie um projeto de exemplo usando a sua ferramenta de construção favorita (**Maven**|**Gradle**).
+2. Adicione a seguinte dependência ao seu projeto de exemplo:
+   * [org.seleniumhq.selenium/selenium-grid](https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-grid)
+3. Adicione o seu Node personalizado ao projeto.
+4. Construa um arquivo JAR do seu projeto usando a sua ferramenta de construção.
+5. Agora, inicie o Node usando o seguinte comando:
 
-1. Create a sample project using your favourite build tool (**Maven**|**Gradle**).
-2. Add the below dependency to your sample project.
-    * [org.seleniumhq.selenium/selenium-grid](https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-grid)
-3. Add your customized Node to the project.
-4. Build a jar of your project using your build tool.
-5. Now start the Node using the command:
 
 ```bash
 java -jar selenium-server-4.6.0.jar \
 --ext custom_node-1.0-SNAPSHOT.jar node \
 --node-implementation org.seleniumhq.samples.DecoratedLoggingNode
 ```
-Below is a sample that just prints some messages on to the console whenever there's an activity of interest (session created, session deleted, a webdriver command executed etc.,) on the Node.
-
+Aqui está um exemplo que apenas imprime algumas mensagens no console sempre que houver uma atividade de interesse (sessão criada, sessão excluída, execução de um comando do webdriver, etc.) no Node.
 
 <details>
 <summary>Sample customized node</summary>
@@ -234,21 +224,21 @@ public class DecoratedLoggingNode extends Node {
 ```
 </details>
 
-**_Foot Notes:_**
+**_Notas de Rodapé:_**
 
-In the above example, the line `Node node = LocalNodeFactory.create(config);` explicitly creates a `LocalNode`.
+No exemplo acima, a linha `Node node = LocalNodeFactory.create(config);` cria explicitamente um `LocalNode`.
 
-There are basically 2 types of *user facing implementations* of `org.openqa.selenium.grid.node.Node` available. 
+Basicamente, existem 2 tipos de implementações *visíveis para o usuário* de `org.openqa.selenium.grid.node.Node` disponíveis. 
 
-These classes are good starting points to learn how to build a custom Node and also to learn the internals of a Node.
+Essas classes são bons pontos de partida para aprender como criar um Node personalizado e também para compreender os detalhes internos de um Node.
 
-* `org.openqa.selenium.grid.node.local.LocalNode` - Used to represent a long running Node and is the default implementation that gets wired in when you start a `node`. 
-    * It can be created by calling `LocalNodeFactory.create(config);`, where:
-      * `LocalNodeFactory` belongs to `org.openqa.selenium.grid.node.local`
-      * `Config` belongs to `org.openqa.selenium.grid.config`
-* `org.openqa.selenium.grid.node.k8s.OneShotNode` - This is a special reference implementation wherein the Node gracefully shuts itself down after servicing one test session. This class is currently not available as part of any pre-built maven artifact.
-  *  You can refer to the source code [here](https://github.com/SeleniumHQ/selenium/blob/trunk/java/src/org/openqa/selenium/grid/node/k8s/OneShotNode.java) to understand its internals. 
-  *  To build it locally refer [here](https://github.com/SeleniumHQ/selenium/blob/trunk/deploys/k8s/README.md). 
-  *  It can be created by calling `OneShotNode.create(config)`, where:
-      * `OneShotNode` belongs to `org.openqa.selenium.grid.node.k8s`
-      * `Config` belongs to `org.openqa.selenium.grid.config`
+* `org.openqa.selenium.grid.node.local.LocalNode` - Usado para representar um Node de execução contínua e é a implementação padrão que é usada quando você inicia um `node`. 
+    * Pode ser criado chamando `LocalNodeFactory.create(config);`, onde:
+      * `LocalNodeFactory` pertence a `org.openqa.selenium.grid.node.local`
+      * `Config` pertence a `org.openqa.selenium.grid.config`
+* `org.openqa.selenium.grid.node.k8s.OneShotNode` - Esta é uma implementação de referência especial em que o Node encerra-se graciosamente após atender a uma sessão de teste. Esta classe atualmente não está disponível como parte de nenhum artefato Maven pré-construído.
+  * Você pode consultar o código-fonte [aqui](https://github.com/SeleniumHQ/selenium/blob/trunk/java/src/org/openqa/selenium/grid/node/k8s/OneShotNode.java) para entender seus detalhes internos.
+  * Para construí-lo localmente, consulte [aqui](https://github.com/SeleniumHQ/selenium/blob/trunk/deploys/k8s/README.md). 
+  * Pode ser criado chamando `OneShotNode.create(config)`, onde:
+      * `OneShotNode` pertence a `org.openqa.selenium.grid.node.k8s`
+      * `Config` pertence a `org.openqa.selenium.grid.config`
diff --git a/website_and_docs/content/documentation/grid/advanced_features/observability.pt-br.md b/website_and_docs/content/documentation/grid/advanced_features/observability.pt-br.md
index e6115f75243..852e33ae390 100644
--- a/website_and_docs/content/documentation/grid/advanced_features/observability.pt-br.md
+++ b/website_and_docs/content/documentation/grid/advanced_features/observability.pt-br.md
@@ -1,116 +1,118 @@
 ---
-title: "Observability"
-linkTitle: "Observability"
+title: "Observabilidade"
+linkTitle: "Observabilidade"
 weight: 1
 aliases: ["/documentation/pt-br/grid/grid_4/advanced_features/observability/"]
 ---
 
 
-{{% pageinfo color="warning" %}}
-<p class="lead">
-   <i class="fas fa-language d-4"></i> 
-   Page being translated from 
-   English to Portuguese. Do you speak Portuguese? Help us to translate
-   it by sending us pull requests!
-</p>
-{{% /pageinfo %}}
-
-
-## Table of Contents
+## Índice
  - [Selenium Grid](#selenium-grid)
- - [Observability](#observability)
-	 - [Distributed tracing](#distributed-tracing) 	
-	 -  [Event logging](#event-logging)
-  - [Grid Observability](#grid-observability)
-	  - [Visualizing Traces](#visualizing-traces)
-	  - [Leveraging event logs](#leveraging-event-logs)
-  - [References](#references)
+ - [Observabilidade](#observabilidade)
+	 - [Rastreamento distribuído](#rastreamento-distribuído) 	
+	 -  [Registro de eventos](#Registro-de-eventos)
+  - [Observabilidade da Grade](#observabilidade-da-grade)
+	  - [Visualizando Traços](#visualizando-traços)
+	  - [Aproveitando logs de eventos](#Aproveitando-logs-de-eventos)
+  - [Referências](#referências)
 
 ## Selenium Grid
 
-Grid aids in scaling and distributing tests by executing tests on various browser and operating system combinations.
+O Grid auxilia na escalabilidade e distribuição de testes, executando testes em várias combinações de navegadores e sistemas operacionais.
+
+## Observabilidade
+
+A observabilidade tem três pilares: rastreamentos, métricas e registros. Como o Selenium Grid 4 foi projetado para ser totalmente distribuído, a observabilidade tornará mais fácil entender e depurar os detalhes internos.
+
+## Rastreamento Distribuído
+Uma única solicitação ou transação abrange vários serviços e componentes. O rastreamento acompanha o ciclo de vida da solicitação à medida que cada serviço a executa. Isso é útil para depurar cenários de erro.
+Alguns termos-chave usados no contexto de rastreamento são:
+
 
-## Observability
+**Rastreamento**
+O rastreamento permite rastrear uma solicitação por meio de vários serviços, desde sua origem até seu destino final. A jornada dessa solicitação ajuda na depuração, no monitoramento do fluxo de ponta a ponta e na identificação de falhas. Um rastreamento representa o fluxo da solicitação de ponta a ponta. Cada rastreamento possui um identificador único.
 
-Observability has three pillars: traces, metrics and logs. Since Selenium Grid 4 is designed to be fully distributed, observability will make it easier to understand and debug the internals. 
 
-## Distributed tracing
-A single request or transaction spans multiple services and components.  Tracing tracks the request lifecycle as each service executes the request. It is useful in debugging in an error scenario.
-Some key terms used in tracing context are: 
+**Segmento**
+Cada rastreamento é composto por operações cronometradas chamadas segmentos. Um segmento possui um horário de início e término e representa operações realizadas por um serviço. A granularidade do segmento depende de como ele é instrumentado. Cada segmento possui um identificador único. Todos os segmentos dentro de um rastreamento têm o mesmo ID de rastreamento.
 
-**Trace**
-Tracing allows one to trace a request through multiple services, starting from its origin to its final destination. This request's journey helps in debugging, monitoring the end-to-end flow, and identifying failures. A trace depicts the end-to-end request flow. Each trace has a unique id as its identifier.
 
-**Span**
-Each trace is made up of timed operations called spans. A span has a start and end time and it represents operations done by a service. The granularity of span depends on how it is instrumented. Each span has a unique identifier.  All spans within a trace have the same trace id.
+**Atributos de Segmento**
+Atributos de segmento são pares de chave e valor que fornecem informações adicionais sobre cada segmento.
 
-**Span Attributes**
-Span attributes are key-value pairs which provide additional information about each span.
+**Eventos**
+Eventos são registros com carimbo de data/hora dentro de um segmento. Eles fornecem contexto adicional para os segmentos existentes. Os eventos também contêm pares de chave e valor como atributos de evento.
 
-**Events**
-Events are timed-stamped logs within a span. They provide additional context to the existing spans. Events also contain key-value pairs as event attributes.
+## Registro de Eventos
 
-## Event logging
+O registro é essencial para depurar um aplicativo. O registro é frequentemente feito em um formato legível por humanos. Mas, para que as máquinas possam pesquisar e analisar os registros, é necessário ter um formato bem definido. O registro estruturado é uma prática comum de registrar logs de forma consistente em um formato fixo. Ele normalmente contém campos como:
 
-Logging is essential to debug an application. Logging is often done in a human-readable format. But for machines to search and analyze the logs, it has to have a well-defined format. Structured logging is a common practice of recording logs consistently in a fixed format. It commonly contains fields like:
- * Timestamp
- * Logging level
- * Logger class
- * Log message (This is further broken down into fields relevant to the operation where the log was recorded)
+ * Carimbo de data/horas
+ * Nível de registro
+ * Classe de registro
+ * Mensagem de registro (isso é detalhado em campos relevantes à operação em que o registro foi feito)
+
+Registros e eventos estão intimamente relacionados. Os eventos encapsulam todas as informações possíveis para realizar uma única unidade de trabalho. Os registros são essencialmente subconjuntos de um evento. No cerne, ambos auxiliam na depuração.
+
+Consulte os recursos a seguir para entender em detalhes:
 
-Logs and events are closely related. Events encapsulate all the possible information available to do a single unit of work. Logs are essentially subsets of an event. At the crux, both aid in debugging.
-Refer following resources for detailed understanding:
  1. [https://www.honeycomb.io/blog/how-are-structured-logs-different-from-events/](https://www.honeycomb.io/blog/how-are-structured-logs-different-from-events/)
  2. [https://charity.wtf/2019/02/05/logs-vs-structured-events/](https://charity.wtf/2019/02/05/logs-vs-structured-events/)
 
-## Grid Observability
+## Observabilidade do Grid
+
+
+O servidor Selenium é instrumentado com rastreamento usando o OpenTelemetry. Cada solicitação ao servidor é rastreada do início ao fim. Cada rastreamento consiste em uma série de segmentos à medida que uma solicitação é executada no servidor. A maioria dos segmentos no servidor Selenium consiste em dois eventos:
+
+1. Evento normal - registra todas as informações sobre uma unidade de trabalho e marca a conclusão bem-sucedida do trabalho.
+2. Evento de erro - registra todas as informações até que ocorra o erro e, em seguida, registra as informações do erro. Marca um evento de exceção.
 
-Selenium server is instrumented with tracing using OpenTelemetry. Every request to the server is traced from start to end. Each trace consists of a series of spans as a request is executed within the server. 
-Most spans in the Selenium server consist of two events:
-1. Normal event - records all information about a unit of work and marks successful completion of the work.
-2. Error event - records all information till the error occurs and then records the error information. Marks an exception event.
+Executando servidor Selenium
 
-Running Selenium server 
  1. [Standalone](https://github.com/SeleniumHQ/selenium/wiki/Selenium-Grid-4#standalone-mode)
  2. [Hub and Node](https://github.com/SeleniumHQ/selenium/wiki/Selenium-Grid-4#hub-and-node)
  3. [Fully Distributed](https://github.com/SeleniumHQ/selenium/wiki/Selenium-Grid-4#fully-distributed)
  4. [Docker](https://github.com/SeleniumHQ/selenium/wiki/Selenium-Grid-4#using-docker)
 
-## Visualizing Traces
-All spans, events and their respective attributes are part of a trace. Tracing works while running the server in all of the above-mentioned modes.
+##  Visualizando Rastreamentos
+Todos os segmentos, eventos e seus respectivos atributos fazem parte de um rastreamento. O rastreamento funciona enquanto o servidor é executado em todos os modos mencionados acima.
+
+Por padrão, o rastreamento está habilitado no servidor Selenium. O servidor Selenium exporta os rastreamentos por meio de dois exportadores:
+
+1. Console - Registra todos os rastreamentos e os segmentos incluídos com nível FINE. Por padrão, o servidor Selenium imprime registros no nível INFO e acima.
+
+A opção **log-level** pode ser usada para definir um nível de registro de sua escolha ao executar o arquivo JAR do Selenium Grid jar/s.
 
-By default, tracing is enabled in the Selenium server. Selenium server exports the traces via two exporters:
-1. Console - Logs all traces and their included spans at FINE level. By default, Selenium server prints logs at INFO level and above. 
-The **log-level** flag can be used to pass a logging level of choice while running the Selenium Grid jar/s.
 ```shell
 java -jar selenium-server-4.0.0-<selenium-version>.jar standalone --log-level FINE
 ```
-2. Jaeger UI - OpenTelemetry provides the APIs and SDKs to instrument traces in the code. Whereas Jaeger is a tracing backend, that aids in collecting the tracing telemetry data and providing querying, filtering and visualizing features for the data.
+2. Jaeger UI - OpenTelemetry fornece as APIs e SDKs para instrumentar rastreamentos no código. Enquanto o Jaeger é um sistema de rastreamento de backend que auxilia na coleta de dados de telemetria de rastreamento e oferece recursos de consulta, filtragem e visualização dos dados.
 
-Detailed instructions of visualizing traces using Jaeger UI can be obtained by running the command :
+Instruções detalhadas sobre como visualizar rastreamentos usando a interface do Jaeger podem ser obtidas executando o seguinte comando:
 
 ```shell
 java -jar selenium-server-4.0.0-<selenium-version>.jar info tracing
 ```
 
-[A very good example and scripts to run the server and send traces to Jaeger](https://github.com/manoj9788/tracing-selenium-grid)
+[Um exemplo muito bom e scripts para executar o servidor e enviar rastreamentos para o Jaeger](https://github.com/manoj9788/tracing-selenium-grid)
+
+## Explorando logs de eventos
+O rastreamento deve estar habilitado para o registro de eventos, mesmo que alguém não deseje exportar rastreamentos para visualizá-los.
+
+**Por padrão, o rastreamento está habilitado. Não é necessário passar parâmetros adicionais para ver os logs no console.**
 
-## Leveraging event logs
-Tracing has to be enabled for event logging as well, even if one does not wish to export traces to visualize them.  
-**By default, tracing is enabled. No additional parameters need to be passed to see logs on the console.**
-All events within a span are logged at FINE level. Error events are logged at WARN level.
+Todos os eventos dentro de um segmento são registrados no nível FINE. Eventos de erro são registrados no nível WARN..
 
-All event logs have the following fields :
- | Field | Field value | Description |
-|-|-|-|
-| Event time | eventId | Timestamp of the event record in epoch nanoseconds. |
-| Trace Id  | tracedId | Each trace is uniquely identified by a trace id. |
-| Span Id  | spanId | Each span within a trace is uniquely identified by a span id. |
-| Span Kind | spanKind | Span kind is a property of span indicating the type of span. It helps in understanding the nature of the unit of work done by the Span. |
-| Event name | eventName | This maps to the log message. |
-| Event attributes | eventAttributes | This forms the crux of the event logs, based on the operation executed, it has JSON formatted key-value pairs. This also includes a handler class attribute, to show the logger class. |
+| Campo | Valor do Campo | Descrição |
+|------|------|------|
+| Hora do Evento | eventId | Carimbo de data/hora do registro do evento em nanossegundos desde a época. |
+| ID de Rastreamento | tracedId | Cada rastreamento é identificado exclusivamente por um ID de rastreamento. |
+| ID de Segmento | spanId | Cada segmento dentro de um rastreamento é identificado exclusivamente por um ID de segmento. |
+| Tipo de Segmento | spanKind | O tipo de segmento é uma propriedade do segmento que indica o tipo de segmento. Isso ajuda a entender a natureza da unidade de trabalho realizada pelo segmento. |
+| Nome do Evento | eventName | Isso mapeia para a mensagem de registro. |
+| Atributos do Evento | eventAttributes | Isso forma a essência dos registros de eventos, com base na operação executada, ele contém pares chave-valor formatados em JSON. Isso também inclui um atributo de classe do manipulador, para mostrar a classe do registro. |
 
- Sample log  
+ Simples log  
 
  
 
@@ -129,15 +131,17 @@ All event logs have the following fields :
       }
     }
     
-In addition to the above fields, based on [OpenTelemetry specification](https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/semantic_conventions/exceptions.md) error logs consist of :
-| Field | Field value | Description |
-|-|-|-|
-| Exception type  | exception.type | The class name of the exception. |
-| Exception message  | exception.message | Reason for the exception. |
-| Exception stacktrace | exception.stacktrace | Prints the call stack at the point of time when the exception was thrown. Helps in understanding the origin of the exception. |
+Além dos campos mencionados anteriormente, com base na [especificação do OpenTelemetry](https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/semantic_conventions/exceptions.md) os registros de erro consistem nos seguintes campos: :
+
+| Campo | Valor do Campo | Descrição |
+|------|------|------|
+| Tipo de Exceção | exception.type | O nome da classe da exceção. |
+| Mensagem da Exceção | exception.message | Motivo da exceção. |
+| Rastreamento de Exceção | exception.stacktrace | Imprime a pilha de chamadas no momento em que a exceção foi lançada. Ajuda a entender a origem da exceção. |
+
  
 
-Sample error log 
+Simples error log 
   
 
     WARN [LoggingOptions$1.lambda$export$1] - {
@@ -156,13 +160,14 @@ Sample error log
       }
     }
 
-Note: Logs are pretty printed above for readability. Pretty printing for logs is turned off in Selenium server.
 
-The steps above should set you up for seeing traces and logs.
- 
-## References 
-1. [Understanding Tracing](https://lightstep.com/blog/opentelemetry-101-what-is-tracing/)
-2. [OpenTelemetry Tracing API Specification](https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/api.md#status)
+**Observação:** Os logs são formatados acima para facilitar a leitura. A formatação de logs está desativada no servidor Selenium.
+
+Os passos acima devem configurá-lo para visualizar rastreamentos e logs.
+
+## Referências
+1. [Compreendendo o Rastreamento](https://lightstep.com/blog/opentelemetry-101-what-is-tracing/)
+2. [Especificação da API de Rastreamento do OpenTelemetry](https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/api.md#status)
 3. [Selenium Wiki](https://github.com/SeleniumHQ/selenium/wiki)
-4. [Structured logs vs events](https://www.honeycomb.io/blog/how-are-structured-logs-different-from-events/)
-5. [Jaeger framework](https://github.com/jaegertracing/jaeger)
+4. [Logs Estruturados vs. Eventos](https://www.honeycomb.io/blog/how-are-structured-logs-different-from-events/)
+5. [Framework Jaeger](https://github.com/jaegertracing/jaeger)
diff --git a/website_and_docs/content/documentation/ie_driver_server/_index.pt-br.md b/website_and_docs/content/documentation/ie_driver_server/_index.pt-br.md
index 568be580486..602f4fcdef2 100755
--- a/website_and_docs/content/documentation/ie_driver_server/_index.pt-br.md
+++ b/website_and_docs/content/documentation/ie_driver_server/_index.pt-br.md
@@ -1,184 +1,183 @@
 ---
-title: "IE Driver Server"
-linkTitle: "IE Driver Server"
+title: "Servidor de drivers do IE"
+linkTitle: "Servidor de drivers do IE"
 weight: 8
 description: >
-    The Internet Explorer Driver is a standalone server that implements the WebDriver specification.
+    O Internet Explorer Driver é um servidor autónomo que implementa a especificação WebDriver.
 ---
-This documentation previously located [on the wiki](https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver-Internals)
+Esta documentação estava anteriormente localizada [on the wiki](https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver-Internals)
 
-The `InternetExplorerDriver` is a standalone server which implements WebDriver's wire protocol.
-This driver has been tested with IE 11, and on Windows 10. It might work with older versions
-of IE and Windows, but this is not supported.
+O `InternetExplorerDriver` é um servidor autónomo que implementa o protocolo wire do WebDriver.
+Este driver foi testado com o IE 11 e no Windows 10. Ele pode funcionar com versões mais antigas
+do IE e do Windows, mas isso não é suportado.
 
-The driver supports running 32-bit and 64-bit versions of the browser. The choice of how to 
-determine which "bit-ness" to use in launching the browser depends on which version of the 
-IEDriverServer.exe is launched. If the 32-bit version of `IEDriverServer.exe` is launched, 
-the 32-bit version of IE will be launched. Similarly, if the 64-bit version of 
-IEDriverServer.exe is launched, the 64-bit version of IE will be launched.
+O controlador suporta a execução de versões de 32 e 64 bits do browser. A escolha de como 
+determinar qual o "bit-ness" a utilizar no lançamento do browser depende de qual a versão do 
+IEDriverServer.exe é lançada. Se a versão de 32 bits do `IEDriverServer.exe` for iniciada, 
+a versão de 32 bits do IE será iniciada. Da mesma forma, se a versão de 64 bits do 
+IEDriverServer.exe for iniciada, a versão de 64 bits do IE será iniciada.
 
-## Installing
+## Instalação
 
-You do not need to run an installer before using the `InternetExplorerDriver`, though some 
-configuration is required. The standalone server executable must be downloaded from 
-the [Downloads](https://www.selenium.dev/downloads/) page and placed in your 
-[PATH](http://en.wikipedia.org/wiki/PATH_(variable)).
+Não é necessário executar um instalador antes de usar o `InternetExplorerDriver`, embora seja necessária alguma 
+configuração seja necessária. O executável do servidor standalone deve ser baixado da página 
+da página [Downloads](https://www.selenium.dev/downloads/) e colocado no seu 
+[PATH](http://en.wikipedia.org/wiki/PATH_(variável)).
 
 ## Pros
 
-* Runs in a real browser and supports JavaScript
+* Funciona num browser real e suporta JavaScript
 
 ## Cons
 
-* Obviously the InternetExplorerDriver will only work on Windows!
-* Comparatively slow (though still pretty snappy :)
+* Obviamente, o InternetExplorerDriver só funciona no Windows!
+* Comparativamente lento (embora ainda bastante rápido :)
 
 ## Command-Line Switches
 
-As a standalone executable, the behavior of the IE driver can be modified through various 
-command-line arguments. To set the value of these command-line arguments, you should 
-consult the documentation for the language binding you are using. The command line 
-switches supported are described in the table below. All -`<switch>`, --`<switch>` 
-and /`<switch>` are supported.
+Como um executável autónomo, o comportamento do controlador IE pode ser modificado através de vários 
+argumentos de linha de comando. Para definir o valor destes argumentos da linha de comandos, deve 
+consultar a documentação do language binding que está a utilizar. As opções de linha de comando 
+suportadas são descritas na tabela abaixo. Todas as opções -`<switch>`, --`<switch>` 
+e /`<switch>` são suportados.
 
-| Switch | Meaning |
+| Switch | Significado |
 |:-------|:--------|
-| --port=`<portNumber>` | Specifies the port on which the HTTP server of the IE driver will listen for commands from language bindings. Defaults to 5555. |
-| --host=`<hostAdapterIPAddress>` | Specifies the IP address of the host adapter on which the HTTP server of the IE driver will listen for commands from language bindings. Defaults to 127.0.0.1. |
-| --log-level=`<logLevel>` | Specifies the level at which logging messages are output. Valid values are FATAL, ERROR, WARN, INFO, DEBUG, and TRACE. Defaults to FATAL. |
-| --log-file=`<logFile>` | Specifies the full path and file name of the log file. Defaults to stdout. |
-| --extract-path=`<path>` | Specifies the full path to the directory used to extract supporting files used by the server. Defaults to the TEMP directory if not specified. |
-| --silent | Suppresses diagnostic output when the server is started. |
+| Especifica a porta na qual o servidor HTTP do driver IE escutará os comandos das associações de idioma. O padrão é 5555. |
+| Especifica o endereço IP do adaptador de anfitrião no qual o servidor HTTP do controlador IE irá escutar os comandos das Language Bindings. O padrão é 127.0.0.1. |
+| --log-level=`<logLevel>` | Especifica o nível em que as mensagens de registo são emitidas. Os valores válidos são FATAL, ERROR, WARN, INFO, DEBUG e TRACE. O padrão é FATAL. |
+| --log-file=`<logFile>` | Especifica o caminho completo e o nome do arquivo de log. O padrão é stdout. |
+| --extract-path=`<path>` | Especifica o caminho completo para o diretório usado para extrair arquivos de suporte usados pelo servidor. O padrão é o diretório TEMP se não for especificado. |
+| --silent | Suprime a saída de diagnóstico quando o servidor é iniciado. |
 
-## Important System Properties
+## Propriedades importantes do sistema
 
-The following system properties (read using `System.getProperty()` and set using
-`System.setProperty()` in Java code or the "`-DpropertyName=value`" command line flag) 
-are used by the `InternetExplorerDriver`:
+As seguintes propriedades do sistema (lidas usando `System.getProperty()` e definidas usando
+`System.setProperty()` no código Java ou o sinalizador de linha de comando "`-DpropertyName=value`") 
+são utilizados pelo `InternetExplorerDriver`:
 
-| **Property** | **What it means** |
+| **Propriedade** | **O que significa** |
 |:-------------|:------------------|
-| `webdriver.ie.driver` | The location of the IE driver binary. |
-| `webdriver.ie.driver.host` | Specifies the IP address of the host adapter on which the IE driver will listen. |
-| `webdriver.ie.driver.loglevel` | Specifies the level at which logging messages are output. Valid values are FATAL, ERROR, WARN, INFO, DEBUG, and TRACE. Defaults to FATAL. |
-| `webdriver.ie.driver.logfile` | Specifies the full path and file name of the log file. |
-| `webdriver.ie.driver.silent` | Suppresses diagnostic output when the IE driver is started. |
-| `webdriver.ie.driver.extractpath` | Specifies the full path to the directory used to extract supporting files used by the server. Defaults to the TEMP directory if not specified. |
-
-## Required Configuration
-
-* The `IEDriverServer` executable must be [downloaded](https://www.selenium.dev/downloads/) and placed in your [PATH](http://en.wikipedia.org/wiki/PATH_(variable)).
-* On IE 7 or higher on Windows Vista, Windows 7, or Windows 10, you must set the Protected Mode settings for each zone to be the same value. The value can be on or off, as long as it is the same for every zone. To set the Protected Mode settings, choose "Internet Options..." from the Tools menu, and click on the Security tab. For each zone, there will be a check box at the bottom of the tab labeled "Enable Protected Mode".
-* Additionally, "Enhanced Protected Mode" must be disabled for IE 10 and higher. This option is found in the Advanced tab of the Internet Options dialog.
-* The browser zoom level must be set to 100% so that the native mouse events can be set to the correct coordinates.
-* For Windows 10, you also need to set "Change the size of text, apps, and other items" to 100% in display settings.
-* For IE 11 _only_, you will need to set a registry entry on the target computer so that the driver can maintain a connection to the instance of Internet Explorer it creates. For 32-bit Windows installations, the key you must examine in the registry editor is `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BFCACHE`. For 64-bit Windows installations, the key is `HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BFCACHE`. Please note that the `FEATURE_BFCACHE` subkey may or may not be present, and should be created if it is not present. **Important:** Inside this key, create a DWORD value named `iexplore.exe` with the value of 0.
-
-## Native Events and Internet Explorer
-
-As the `InternetExplorerDriver` is Windows-only, it attempts to use so-called "native", or OS-level 
-events to perform mouse and keyboard operations in the browser. This is in contrast to using 
-simulated JavaScript events for the same operations. The advantage of using native events is that 
-it does not rely on the JavaScript sandbox, and it ensures proper JavaScript event propagation 
-within the browser. However, there are currently some issues with mouse events when the IE 
-browser window does not have focus, and when attempting to hover over elements.
-
-### Browser Focus
-
-The challenge is that IE itself appears to not fully respect the Windows messages we send the 
-IE browser window (`WM\_MOUSEDOWN` and `WM\_MOUSEUP`) if the window doesn't have the focus. 
-Specifically, the element being clicked on will receive a focus window around it, but the click 
-will not be processed by the element. Arguably, we shouldn't be sending messages at all; rather, 
-we should be using the `SendInput()` API, but that API explicitly requires the window to have the 
-focus. We have two conflicting goals with the WebDriver project.
-
-First, we strive to emulate the user as closely as possible. This means using native events 
-rather than simulating the events using JavaScript.
-
-Second, we want to not require focus of the browser window being automated. This means that 
-just forcing the browser window to the foreground is suboptimal.
-
-An additional consideration is the possibility of multiple IE instances running under multiple 
-WebDriver instances, which means any such "bring the window to the foreground" solution will 
-have to be wrapped in some sort of synchronizing construct (mutex?) within the IE driver's 
-C++ code. Even so, this code will still be subject to race conditions, if, for example, the 
-user brings another window to the foreground between the driver bringing IE to the foreground 
-and executing the native event.
-
-The discussion around the requirements of the driver and how to prioritize these two 
-conflicting goals is ongoing. The current prevailing wisdom is to prioritize the former over 
-the latter, and document that your machine will be unavailable for other tasks when using 
-the IE driver. However, that decision is far from finalized, and the code to implement it is 
-likely to be rather complicated.
-
-### Hovering Over Elements
-
-When you attempt to hover over elements, and your physical mouse cursor is within the boundaries 
-of the IE browser window, the hover will not work. More specifically, the hover will appear 
-to work for a fraction of a second, and then the element will revert back to its previous 
-state. The prevailing theory why this occurs is that IE is doing hit-testing of some sort 
-during its event loop, which causes it to respond to the physical mouse position when the 
-physical cursor is within the window bounds. The WebDriver development team has been unable 
-to discover a workaround for this behavior of IE.
-
-### Clicking `<option>` Elements or Submitting Forms and `alert()`
-
-There are two places where the IE driver does not interact with elements using native events. 
-This is in clicking `<option>` elements within a `<select>` element. Under normal circumstances, 
-the IE driver calculates where to click based on the position and size of the element, typically 
-as returned by the JavaScript `getBoundingClientRect()` method. However, for `<option>` elements, 
-`getBoundingClientRect()` returns a rectangle with zero position and zero size. The IE driver 
-handles this one scenario by using the `click()` Automation Atom, which essentially sets 
-the `.selected` property of the element and simulates the `onChange` event in JavaScript. 
-However, this means that if the `onChange` event of the `<select>` element contains JavaScript 
-code that calls `alert()`, `confirm()` or `prompt()`, calling WebElement's `click()` method will 
-hang until the modal dialog is manually dismissed. There is no known workaround for this behavior 
-using only WebDriver code.
-
-Similarly, there are some scenarios when submitting an HTML form via WebElement's `submit()` 
-method may have the same effect. This can happen if the driver calls the JavaScript `submit()` 
-function on the form, and there is an onSubmit event handler that calls the JavaScript `alert()`, 
-`confirm()`, or `prompt()` functions.
-
-This restriction is filed as issue 3508 (on Google Code).
-
-## Multiple instances of `InternetExplorerDriver`
-
-With the creation of the `IEDriverServer.exe`, it should be possible to create and use multiple 
-simultaneous instances of the `InternetExplorerDriver`. However, this functionality is largely 
-untested, and there may be issues with cookies, window focus, and the like. If you attempt to 
-use multiple instances of the IE driver, and run into such issues, consider using the 
-`RemoteWebDriver` and virtual machines.
-
-There are 2 solutions for problem with cookies (and another session items) shared between 
-multiple instances of InternetExplorer.
-
-The first is to start your InternetExplorer in private mode. After that InternetExplorer will be 
-started with clean session data and will not save changed session data at quiting. To do so you 
-need to pass 2 specific capabilities to driver: `ie.forceCreateProcessApi` with `true` value 
-and `ie.browserCommandLineSwitches` with `-private` value. Be note that it will work only 
-for InternetExplorer 8 and newer, and Windows Registry 
-`HKLM_CURRENT_USER\\Software\\Microsoft\\Internet Explorer\\Main` path should contain key 
-`TabProcGrowth` with `0` value.
-
-The second is to clean session during InternetExplorer starting. For this you need to pass 
-specific `ie.ensureCleanSession` capability with `true` value to driver. This clears the cache 
-for all running instances of InternetExplorer, including those started manually.
-
-## Running `IEDriverServer.exe` Remotely
-
-The HTTP server started by the `IEDriverServer.exe` sets an access control list to only accept 
-connections from the local machine, and disallows incoming connections from remote machines. 
-At present, this cannot be changed without modifying the source code to the `IEDriverServer.exe`. 
-To run the Internet Explorer driver on a remote machine, use the Java standalone remote server 
-in connection with your language binding's equivalent of `RemoteWebDriver`.
-
-## Running `IEDriverServer.exe` Under a Windows Service
-
-Attempting to use IEDriverServer.exe as part of a Windows Service application is expressly 
-unsupported. Service processes, and processes spawned by them, have much different requirements 
-than those executing in a regular user context. `IEDriverServer.exe` is explicitly untested in 
-that environment, and includes Windows API calls that are documented to be prohibited to be used 
-in service processes. While it may be possible to get the IE driver to work while running under 
-a service process, users encountering problems in that environment will need to seek out their 
-own solutions.
+| `webdriver.ie.driver` | A localização do binário do driver do IE. |
+| Especifica o endereço IP do adaptador do host no qual o driver do IE escutará. |
+| Especifica o nível em que as mensagens de registo são emitidas. Os valores válidos são FATAL, ERROR, WARN, INFO, DEBUG e TRACE. O padrão é FATAL. |
+| Especifica o caminho completo e o nome do arquivo de log. |
+| `webdriver.ie.driver.silent` | Suprime a saída de diagnóstico quando o driver do IE é iniciado. |
+| Especifica o caminho completo para o diretório usado para extrair arquivos de suporte usados pelo servidor. O padrão é o diretório TEMP se não for especificado. |
+
+## Configuração Necessária
+
+* O executável `IEDriverServer` deve ser [descarregado](https://www.selenium.dev/downloads/) e colocado no seu [PATH](http://en.wikipedia.org/wiki/PATH_(variável)).
+* No IE 7 ou superior no Windows Vista, Windows 7 ou Windows 10, você deve definir as configurações do Modo Protegido para cada zona com o mesmo valor. O valor pode ser ligado ou desligado, desde que seja o mesmo para todas as zonas. Para definir as definições do Modo Protegido, escolha "Opções da Internet..." no menu Ferramentas e clique no separador Segurança. Para cada zona, existe uma caixa de verificação na parte inferior do separador com a designação "Ativar Modo Protegido".
+* Além disso, o "Modo Protegido Avançado" deve ser desativado para o IE 10 e superior. Esta opção encontra-se no separador Avançadas da caixa de diálogo Opções da Internet.
+* O nível de zoom do navegador deve ser definido para 100% para que os eventos nativos do rato possam ser definidos para as coordenadas correctas.
+* Para o Windows 10, também é necessário definir "Alterar o tamanho do texto, das aplicações e de outros itens" para 100% nas definições de visualização.
+* Para o IE 11 _apenas_, terá de definir uma entrada de registo no computador de destino para que o controlador possa manter uma ligação à instância do Internet Explorer que cria. Para instalações Windows de 32 bits, a chave que deve examinar no editor de registo é `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BFCACHE`. Para instalações do Windows de 64 bits, a chave é `HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BFCACHE`. Tenha em atenção que a subchave `FEATURE_BFCACHE` pode ou não estar presente, e deve ser criada se não estiver presente. **Importante:** Dentro desta chave, crie um valor DWORD chamado `iexplore.exe` com o valor 0.
+
+## Eventos Nativos e Internet Explorer
+
+Como o `InternetExplorerDriver` é apenas para Windows, ele tenta usar os chamados eventos "nativos", ou de nível de SO 
+para executar operações de mouse e teclado no navegador. Isto está em contraste com o uso de 
+eventos JavaScript simulados para as mesmas operações. A vantagem de usar eventos nativos é que 
+não depende da sandbox do JavaScript e garante a propagação adequada de eventos JavaScript 
+dentro do navegador. No entanto, existem atualmente alguns problemas com eventos de rato quando a janela do browser IE 
+não tem foco, e quando se tenta passar o mouse sobre elementos.
+
+### Foco no navegador
+
+O desafio é que o próprio IE parece não respeitar totalmente as mensagens do Windows que enviamos para a 
+janela do navegador IE (`WM\_MOUSEDOWN` e `WM\_MOUSEUP`) se a janela não tiver o foco. 
+Especificamente, o elemento que está sendo clicado receberá uma janela de foco em torno dele, mas o clique 
+não será processado pelo elemento. Provavelmente, nós não deveríamos estar enviando mensagens; ao invés disso, 
+deveríamos estar usando a API `SendInput()`, mas essa API requer explicitamente que a janela tenha o 
+foco. Nós temos dois objetivos conflitantes com o projeto WebDriver.
+
+Primeiro, nós nos esforçamos para emular o usuário o mais próximo possível. Isso significa usar eventos nativos 
+em vez de simular os eventos usando JavaScript.
+
+Em segundo lugar, queremos não exigir o foco da janela do browser que está a ser automatizada. Isto significa que 
+apenas forçar a janela do navegador para o primeiro plano é subótimo.
+
+Uma consideração adicional é a possibilidade de várias instâncias do IE serem executadas em várias instâncias do 
+instâncias do WebDriver, o que significa que qualquer solução do tipo "trazer a janela para o primeiro plano" terá 
+terá que ser envolvida em algum tipo de construção de sincronização (mutex?) dentro do código C++ do driver do IE. 
+código C++ do driver do IE. Mesmo assim, esse código ainda estará sujeito a condições de corrida, se, por exemplo, o 
+utilizador colocar outra janela em primeiro plano entre o driver colocar o IE em primeiro plano 
+e a execução do evento nativo.
+
+A discussão sobre os requisitos do controlador e a forma de dar prioridade a estes dois objectivos 
+objectivos contraditórios está em curso. A sabedoria predominante atual é dar prioridade ao primeiro em detrimento do segundo e documentar que a sua máquina 
+o segundo, e documentar que sua máquina ficará indisponível para outras tarefas ao usar 
+o driver do IE. No entanto, essa decisão está longe de ser finalizada, e o código para implementá-la é 
+provavelmente será bastante complicado.
+
+### Passar o rato sobre elementos
+
+Quando você tenta passar o mouse sobre elementos e o cursor físico do mouse está dentro dos limites 
+da janela do navegador IE, o hover não funcionará. Mais especificamente, o hover parecerá 
+funcionar por uma fração de segundo, e então o elemento voltará ao seu estado anterior. 
+anterior. A teoria prevalecente sobre o motivo pelo qual isso ocorre é que o IE está fazendo algum tipo de teste de acerto 
+durante o seu ciclo de eventos, o que faz com que responda à posição física do rato quando o 
+quando o cursor físico está dentro dos limites da janela. A equipa de desenvolvimento do WebDriver não conseguiu 
+de descobrir uma solução alternativa para esse comportamento do IE.
+
+### Clicando em elementos `<option>` ou enviando formulários e `alert()`
+
+Há dois lugares onde o driver do IE não interage com elementos usando eventos nativos
+Isso ocorre ao clicar em elementos `<option>` dentro de um elemento `<select>`. Sob circunstâncias normais,
+o driver do IE calcula onde clicar com base na posição e tamanho do elemento, normalmente
+conforme retornado pelo método JavaScript `getBoundingClientRect()`. No entanto, para elementos `<option>`,
+`getBoundingClientRect()` retorna um retângulo com posição zero e tamanho zero. O driver do IE
+lida com esse cenário usando o Automation Atom `click()`, que essencialmente define
+a propriedade `.selected` do elemento e simula o evento `onChange` em JavaScript.
+No entanto, isso significa que se o evento `onChange` do elemento `<select>` contiver JavaScript
+código que chama `alert()`, `confirm()` ou `prompt()`, chamar o método `click()` do WebElement irá
+aguarde até que a caixa de diálogo modal seja descartada manualmente. Não há solução alternativa conhecida para esse comportamento usando apenas o código WebDriver.
+
+Da mesma forma, há alguns cenários em que a submissão de um formulário HTML através do método `submit()` do WebElement pode ter o mesmo efeito. 
+do WebElement pode ter o mesmo efeito. Isso pode acontecer se o driver chamar a função JavaScript `submit()` 
+do JavaScript no formulário, e houver um manipulador de eventos onSubmit que chame o método JavaScript `alert()`, 
+`confirm()`, ou `prompt()` do JavaScript.
+
+Esta restrição está registada como problema 3508 (no Google Code).
+
+## Múltiplas instâncias do `InternetExplorerDriver`
+
+Com a criação do `IEDriverServer.exe`, deve ser possível criar e utilizar múltiplas instâncias simultâneas do `InternetExplorerDriver`. 
+instâncias simultâneas do `InternetExplorerDriver`. Entretanto, esta funcionalidade ainda não foi 
+não foi testada, e pode haver problemas com cookies, foco de janela, e coisas do tipo. Se você tentar 
+utilizar múltiplas instâncias do driver do IE, e se deparar com tais problemas, considere utilizar o 
+`RemoteWebDriver` e máquinas virtuais.
+
+Existem 2 soluções para o problema dos cookies (e outros itens de sessão) partilhados entre 
+várias instâncias do InternetExplorer.
+
+A primeira é iniciar o InternetExplorer em modo privado. Depois disso, o InternetExplorer será 
+iniciado com dados de sessão limpos e não guardará os dados de sessão alterados ao sair. Para o fazer, é necessário 
+precisa passar 2 capacidades específicas para o driver: `ie.forceCreateProcessApi` com valor `true 
+e `ie.browserCommandLineSwitches` com o valor `private`. Note que isso só funcionará 
+para o InternetExplorer 8 e mais recentes, e o Registo do Windows 
+O caminho `HKLM_CURRENT_USER\\Software\\Microsoft\\Internet Explorer\\Main` deve conter a chave 
+`TabProcGrowth` com o valor `0`.
+
+A segunda é limpar a sessão durante a inicialização do InternetExplorer. Para isso é necessário passar 
+capacidade específica `ie.ensureCleanSession` com valor `true` para o driver. Isso limpa o cache 
+para todas as instâncias em execução do InternetExplorer, incluindo aquelas iniciadas manualmente.
+
+## Executando o `IEDriverServer.exe` remotamente
+
+O servidor HTTP iniciado pelo `IEDriverServer.exe` define uma lista de controlo de acesso para aceitar apenas 
+conexões da máquina local, e não permite conexões de entrada de máquinas remotas. 
+No momento, isso não pode ser alterado sem modificar o código fonte do `IEDriverServer.exe`. 
+Para executar o driver do Internet Explorer em uma máquina remota, use o servidor remoto Java standalone 
+em conexão com o equivalente do `RemoteWebDriver` da sua linguagem de ligação.
+
+## Executando o `IEDriverServer.exe` em um serviço do Windows
+
+A tentativa de usar o IEDriverServer.exe como parte de um aplicativo de serviço do Windows é expressamente 
+não é suportado. Os processos de serviço, e os processos gerados por eles, têm requisitos muito diferentes 
+do que aqueles que são executados num contexto de utilizador normal. O `IEDriverServer.exe` não é explicitamente testado nesse 
+ambiente, e inclui chamadas da API do Windows que são documentadas como proibidas de serem usadas 
+em processos de serviço. Embora seja possível fazer com que o driver do IE funcione durante a execução em um processo de serviço, os usuários que encontrarem problemas 
+um processo de serviço, os utilizadores que encontrarem problemas nesse ambiente terão de procurar as suas 
+suas próprias soluções.
diff --git a/website_and_docs/content/documentation/test_practices/testing_types.en.md b/website_and_docs/content/documentation/test_practices/testing_types.en.md
index 849dc00860f..14dcd78c6d9 100644
--- a/website_and_docs/content/documentation/test_practices/testing_types.en.md
+++ b/website_and_docs/content/documentation/test_practices/testing_types.en.md
@@ -42,6 +42,16 @@ done directly with Selenium by simulating expected returns.
 This simulation could be done by record/playback or through 
 the different supported languages as explained in this documentation.
 
+### Integration Tests
+
+Integration tests verify the interactions between different components or modules of a system. Several modules are together tested. The purpose of Integration tests is to make sure that all modules integrate and work together as expected. Automated integration tests help ensure that these interactions work as expected and that integrated components function properly together.
+>For example,  **_Testing the flow of placing the order for an item in an ecommerce website along with payment._**
+
+### System Tests
+
+System Testing is a complete fully integrated product Testing. It is an end-to-end testing where in testing environment is similar to the production environment. Here, we navigate through all the features of the software and test if the end business / end feature works. We just test the end feature and don’t check for data flow or do functional testing and all.
+>For example,  **_Testing the end to end flow from login to placing and order and rechecking the order in My Orders page and logoff from an ecommerce website._**
+
 ### Performance testing
 As its name indicates, performance tests are done 
 to measure how well an application is performing.
diff --git a/website_and_docs/content/documentation/test_practices/testing_types.pt-br.md b/website_and_docs/content/documentation/test_practices/testing_types.pt-br.md
index 8ced1a03f1b..ecbbbc6852c 100644
--- a/website_and_docs/content/documentation/test_practices/testing_types.pt-br.md
+++ b/website_and_docs/content/documentation/test_practices/testing_types.pt-br.md
@@ -42,6 +42,16 @@ feito diretamente com o Selenium, simulando os retornos esperados.
 Esta simulação pode ser feita por gravação / reprodução ou por meio de
 os diferentes idiomas suportados, conforme explicado nesta documentação.
 
+### Testes de Integração
+
+Os testes de integração verificam as interações entre diferentes componentes ou módulos de um sistema. Vários módulos são testados juntos. O objetivo dos testes de integração é garantir que todos os módulos se integrem e funcionem juntos conforme esperado. Os testes de integração automatizados ajudam a garantir que essas interações funcionem conforme o esperado e que os componentes integrados funcionem corretamente juntos.
+>Por exemplo, **_Testando o fluxo de pedido de um item em um site de comércio eletrônico junto com o pagamento._**
+
+### Testes de sistema
+
+O System Testing é um teste de produto completo e totalmente integrado. É um teste ponta a ponta onde o ambiente de teste é semelhante ao ambiente de produção. Aqui, navegamos por todos os recursos do software e testamos se o negócio final/recurso final funciona. Apenas testamos o recurso final e não verificamos o fluxo de dados, nem fazemos testes funcionais e tudo mais.
+>Por exemplo, **_Testando o fluxo de ponta a ponta desde o login até a colocação e pedido e verificando novamente o pedido na página Meus Pedidos e logoff de um site de comércio eletrônico._**
+
 ### Teste de performance/desempenho
 Como o próprio nome indica, testes de desempenho são feitos
 para medir o desempenho de um aplicativo.
diff --git a/website_and_docs/content/documentation/webdriver/actions_api/_index.pt-br.md b/website_and_docs/content/documentation/webdriver/actions_api/_index.pt-br.md
index 255929fd2c1..c4d9233da75 100644
--- a/website_and_docs/content/documentation/webdriver/actions_api/_index.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/actions_api/_index.pt-br.md
@@ -1,35 +1,21 @@
 ---
-title: "Actions API"
-linkTitle: "Actions API"
+title: "Ações API"
+linkTitle: "Ações API"
 weight: 14
 description: >
-    A low-level interface for providing virtualized device input actions to the web browser.
+    Uma interface de baixo nível para fornecer ações de entrada de dispositivo virtualizadas para o navegador da web..
 ---
+Além das [interações de alto nível]({{< ref "/documentation/webdriver/elements/interactions.md" >}}), a [API de Ações](https://w3c.github.io/webdriver/#dfn-actions) oferece controle detalhado sobre o que dispositivos de entrada designados podem fazer. O Selenium fornece uma interface para 3 tipos de fontes de entrada: entrada de teclado para dispositivos de teclado, entrada de ponteiro para mouse, caneta ou dispositivos de toque, e entrada de roda para dispositivos de roda de rolagem (introduzida no Selenium 4.2). O Selenium permite que você construa comandos de ação individuais atribuídos a entradas específicas, encadeie-os e chame o método de execução associado para executá-los todos de uma vez.
 
-In addition to the high-level [element interactions]({{< ref "/documentation/webdriver/elements/interactions.md" >}}), 
-the [Actions API](https://w3c.github.io/webdriver/#dfn-actions) provides granular control over
-exactly what designated input devices can do. Selenium provides an interface for 3 kinds of input sources: 
-a key input for keyboard devices, a pointer input for a mouse, pen or touch devices, 
-and wheel inputs for scroll wheel devices (introduced in Selenium 4.2). 
-Selenium allows you to construct individual action commands assigned to specific
-inputs and chain them together and call the associated perform method to execute them all at once.
+## Construtor de Ações
 
-## Action Builder
+Na transição do antigo Protocolo JSON Wire para o novo Protocolo W3C WebDriver, os componentes de construção de ações de baixo nível se tornaram especialmente detalhados. Isso é extremamente poderoso, mas cada dispositivo de entrada possui várias maneiras de ser utilizado e, se você precisa gerenciar mais de um dispositivo, é responsável por garantir a sincronização adequada entre eles.
 
-In the move from the legacy JSON Wire Protocol to the new W3C WebDriver Protocol,
-the low level building blocks of actions became especially detailed. It is extremely
-powerful, but each input device has a number of ways to use it and if you need to 
-manage more than one device, you are responsible for ensuring proper synchronization between them.
+Felizmente, provavelmente você não precisa aprender a usar os comandos de baixo nível diretamente, uma vez que quase tudo o que você pode querer fazer foi fornecido com um método de conveniência que combina os comandos de nível inferior para você. Todos esses métodos estão documentados nas páginas de [teclado]({{< ref "keyboard" >}}), [mouse]({{< ref "mouse" >}}), [caneta]({{< ref "pen" >}}) e [roda]({{< ref "wheel" >}}).
 
-Thankfully, you likely do not need to learn how to use the low level commands directly, since
-almost everything you might want to do has been given a convenience method that combines the 
-lower level commands for you. These are all documented in 
-[keyboard]({{< ref "keyboard" >}}), [mouse]({{< ref "mouse" >}}), [pen]({{< ref "pen" >}}), and [wheel]({{< ref "wheel" >}}) pages.
+## Pausa
 
-## Pause
-
-Pointer movements and Wheel scrolling allow the user to set a duration for the action, but sometimes you just need
-to wait a beat between actions for things to work correctly.
+Movimentos de ponteiro e rolagem da roda permitem que o usuário defina uma duração para a ação, mas às vezes você só precisa esperar um momento entre as ações para que as coisas funcionem corretamente.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -54,15 +40,11 @@ to wait a beat between actions for things to work correctly.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Release All Actions
+## Liberar Todas as Ações
 
-An important thing to note is that the driver remembers the state of all the input
-items throughout a session. Even if you create a new instance of an actions class, the depressed keys and
-the location of the pointer will be in whatever state a previously performed action left them.
+Um ponto importante a ser observado é que o driver lembra o estado de todos os itens de entrada ao longo de uma sessão. Mesmo se você criar uma nova instância de uma classe de ações, as teclas pressionadas e a posição do ponteiro permanecerão no estado em que uma ação previamente executada os deixou.
 
-There is a special method to release all currently depressed keys and pointer buttons.
-This method is implemented differently in each of the languages because
-it does not get executed with the perform method.
+Existe um método especial para liberar todas as teclas pressionadas e botões do ponteiro atualmente pressionados. Esse método é implementado de maneira diferente em cada uma das linguagens porque não é executado com o método de execução (perform).
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
diff --git a/website_and_docs/content/documentation/webdriver/actions_api/keyboard.pt-br.md b/website_and_docs/content/documentation/webdriver/actions_api/keyboard.pt-br.md
index c1d65ebd5c9..ca5355150ea 100644
--- a/website_and_docs/content/documentation/webdriver/actions_api/keyboard.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/actions_api/keyboard.pt-br.md
@@ -1,26 +1,21 @@
 ---
-title: "Keyboard actions"
-linkTitle: "Keyboard"
+title: "Ações de Teclado"
+linkTitle: "Teclado"
 weight: 2
 description: >
-  A representation of any key input device for interacting with a web page.
+  Uma representação de qualquer dispositivo de entrada de teclado para interagir com uma página da web.
 aliases: [
 "/documentation/pt-br/webdriver/keyboard/",
 "/pt-br/documentation/webdriver/keyboard/"
 ]
 ---
 
-There are only 2 actions that can be accomplished with a keyboard:
-pressing down on a key, and releasing a pressed key.
-In addition to supporting ASCII characters, each keyboard key has
-a representation that can be pressed or released in designated sequences.
+Existem apenas 2 ações que podem ser realizadas com um teclado: pressionar uma tecla e liberar uma tecla pressionada. Além de suportar caracteres ASCII, cada tecla do teclado possui uma representação que pode ser pressionada ou liberada em sequências designadas.
 
-## Keys
+## Chaves
 
-In addition to the keys represented by regular unicode, 
-unicode values have been assigned to other keyboard keys for use with Selenium. 
-Each language has its own way to reference these keys; the full list can be found
-[here](https://www.w3.org/TR/webdriver/#keyboard-actions).
+Além das teclas representadas pelo Unicode regular, valores Unicode foram atribuídos a outras teclas de teclado para uso com o Selenium. Cada linguagem tem sua própria maneira de fazer referência a essas teclas; a lista completa pode ser encontrada
+[aqui](https://www.w3.org/TR/webdriver/#keyboard-actions).
 
 {{< tabpane text=true langEqualsHeader=true >}}
     {{< tab header="Java" >}}
@@ -43,7 +38,7 @@ Use the [Java Keys enum](https://github.com/SeleniumHQ/selenium/blob/selenium-4.
     {{< /tab >}}
 {{< /tabpane >}}
 
-## Key down
+## Pressione a tecla
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -66,7 +61,7 @@ Use the [Java Keys enum](https://github.com/SeleniumHQ/selenium/blob/selenium-4.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Key up
+## Liberar a tecla
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -89,13 +84,13 @@ Use the [Java Keys enum](https://github.com/SeleniumHQ/selenium/blob/selenium-4.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Send keys
+## Enviar teclas
 
 This is a convenience method in the Actions API that combines keyDown and keyUp commands in one action.
 Executing this command differs slightly from using the element method, but
 primarily this gets used when needing to type multiple characters in the middle of other actions.
 
-### Active Element
+### Elemento Ativo
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -118,7 +113,7 @@ primarily this gets used when needing to type multiple characters in the middle
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Designated Element
+### Elemento Designado
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -142,11 +137,9 @@ primarily this gets used when needing to type multiple characters in the middle
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Copy and Paste
+## Copiar e Colar
 
-Here's an example of using all of the above methods to conduct a copy / paste action.
-Note that the key to use for this operation will be different depending on if it is a Mac OS or not.
-This code will end up with the text: `SeleniumSelenium!`
+Aqui está um exemplo de uso de todos os métodos acima para realizar uma ação de copiar/colar. Note que a tecla a ser usada para essa operação será diferente, dependendo se for um sistema Mac OS ou não. Este código resultará no texto: `SeleniumSelenium!`
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
diff --git a/website_and_docs/content/documentation/webdriver/actions_api/mouse.pt-br.md b/website_and_docs/content/documentation/webdriver/actions_api/mouse.pt-br.md
index 018d09ad2bb..75315131b97 100644
--- a/website_and_docs/content/documentation/webdriver/actions_api/mouse.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/actions_api/mouse.pt-br.md
@@ -1,24 +1,21 @@
 ---
-title: "Mouse actions"
+title: "Ações do Mouse"
 linkTitle: "Mouse"
 weight: 4
 needsTranslation: true
 description: >
-  A representation of any pointer device for interacting with a web page.
+  Uma representação de qualquer dispositivo de ponteiro para interagir com uma página da web.
 aliases: [
 "/documentation/pt-br/support_packages/mouse_and_keyboard_actions_in_detail/",
 "/pt-br/documentation/support_packages/mouse_and_keyboard_actions_in_detail/"
 ]
 ---
 
-There are only 3 actions that can be accomplished with a mouse:
-pressing down on a button, releasing a pressed button, and moving the mouse.
-Selenium provides convenience methods that combine these actions in the most common ways.
+Existem apenas 3 ações que podem ser realizadas com um mouse: pressionar um botão, liberar um botão pressionado e mover o mouse. O Selenium fornece métodos de conveniência que combinam essas ações da maneira mais comum.
 
-## Click and hold
+## Clicar e Manter Pressionado
 
-This method combines moving the mouse to the center of an element with pressing the left mouse button.
-This is useful for focusing a specific element:
+Este método combina mover o mouse para o centro de um elemento com a pressão do botão esquerdo do mouse. Isso é útil para focar em um elemento específico:
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -41,10 +38,9 @@ This is useful for focusing a specific element:
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Click and release
+## Clicar e Liberar
 
-This method combines moving to the center of an element with pressing and releasing the left mouse button.
-This is otherwise known as "clicking":
+Este método combina mover o mouse para o centro de um elemento com a pressão e liberação do botão esquerdo do mouse. Isso é conhecido como "clicar":
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -67,19 +63,20 @@ This is otherwise known as "clicking":
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Alternate Button Clicks
+## Clique com o Botão Alternativo
 
-There are a total of 5 defined buttons for a Mouse:
-* 0 — Left Button (the default)
-* 1 — Middle Button (currently unsupported)
-* 2 — Right Button
-* 3 — X1 (Back) Button
-* 4 — X2 (Forward) Button
+Existem um total de 5 botões definidos para um mouse:
+- 0 — Botão Esquerdo (o padrão)
+- 1 — Botão do Meio (atualmente não suportado)
+- 2 — Botão Direito
+- 3 — Botão X1 (Voltar)
+- 4 — Botão X2 (Avançar)
 
-### Context Click
 
-This method combines moving to the center of an element with pressing and releasing the right mouse button (button 2).
-This is otherwise known as "right-clicking":
+###  Context Click
+
+Este método combina mover o mouse para o centro de um elemento com a pressão e liberação do botão direito do mouse (botão 2). Isso é conhecido como "clicar com o botão direito" ou "menu de contexto"
+
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -102,9 +99,9 @@ This is otherwise known as "right-clicking":
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Back Click
+### Click botão de voltar do mouse
 
-There is no convenience method for this, it is just pressing and releasing mouse button 3
+Este termo pode se referir a um clique com o botão X1 (botão de voltar) do mouse. No entanto, essa terminologia específica pode variar dependendo do contexto.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -131,9 +128,9 @@ There is no convenience method for this, it is just pressing and releasing mouse
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Forward Click
+### botão de avançar) do mouse
 
-There is no convenience method for this, it is just pressing and releasing mouse button 4
+Este termo se refere a um clique com o botão X2 (botão de avançar) do mouse. Não existe um método de conveniência específico para essa ação, sendo apenas a pressão e liberação do botão do mouse de número 4.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -160,9 +157,9 @@ There is no convenience method for this, it is just pressing and releasing mouse
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Double click
+## Duplo click
 
-This method combines moving to the center of an element with pressing and releasing the left mouse button twice.
+Este método combina mover o mouse para o centro de um elemento com a pressão e liberação do botão esquerdo do mouse duas vezes. Isso é conhecido como "duplo clique".
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -185,11 +182,9 @@ This method combines moving to the center of an element with pressing and releas
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Move to element
+## Mover para o Elemento
 
-This method moves the mouse to the in-view center point of the element. 
-This is otherwise known as "hovering."
-Note that the element must be in the viewport or else the command will error.
+Este método move o mouse para o ponto central do elemento que está visível na tela. Isso é conhecido como "hovering" ou "pairar". É importante observar que o elemento deve estar no viewport (área visível na tela) ou então o comando resultará em erro.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -212,16 +207,13 @@ Note that the element must be in the viewport or else the command will error.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Move by offset
+## Mover por Deslocamento
 
-These methods first move the mouse to the designated origin and then
-by the number of pixels in the provided offset.
-Note that the position of the mouse must be in the viewport or else the command will error.
+Esses métodos primeiro movem o mouse para a origem designada e, em seguida, pelo número de pixels especificado no deslocamento fornecido. É importante observar que a posição do mouse deve estar dentro da janela de visualização (viewport) ou, caso contrário, o comando resultará em erro.
 
-### Offset from Element
+### Deslocamento a partir do Elemento
 
-This method moves the mouse to the in-view center point of the element,
-then moves by the provided offset.
+Este método move o mouse para o ponto central do elemento visível na tela e, em seguida, move o mouse pelo deslocamento fornecido.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -244,10 +236,9 @@ then moves by the provided offset.
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Offset from Viewport
+### Deslocamento a partir da Janela de Visualização
 
-This method moves the mouse from the upper left corner of the current viewport by the provided
-offset.
+Este método move o mouse a partir do canto superior esquerdo da janela de visualização atual pelo deslocamento fornecido.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -270,16 +261,10 @@ offset.
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Offset from Current Pointer Location
-
-This method moves the mouse from its current position by the offset provided by the user.
-If the mouse has not previously been moved, the position will be in the upper left
-corner of the viewport.
-Note that the pointer position does not change when the page is scrolled.
+### Deslocamento a partir da Localização Atual do Ponteiro
+Este método move o mouse a partir de sua posição atual pelo deslocamento fornecido pelo usuário. Se o mouse não tiver sido movido anteriormente, a posição será no canto superior esquerdo da janela de visualização. É importante notar que a posição do ponteiro não muda quando a página é rolada.
 
-Note that the first argument X specifies to move right when positive, while the second argument
-Y specifies to move down when positive. So `moveByOffset(30, -10)` moves right 30 and up 10 from
-the current mouse position.
+Observe que o primeiro argumento, X, especifica o movimento para a direita quando positivo, enquanto o segundo argumento, Y, especifica o movimento para baixo quando positivo. Portanto, `moveByOffset(30, -10)` move o mouse 30 unidades para a direita e 10 unidades para cima a partir da posição atual do mouse.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -302,10 +287,9 @@ the current mouse position.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Drag and Drop on Element
+## Arrastar e Soltar no Elemento
 
-This method firstly performs a click-and-hold on the source element, 
-moves to the location of the target element and then releases the mouse.
+Este método primeiro realiza um clique e mantém pressionado no elemento de origem, move para a localização do elemento de destino e, em seguida, libera o botão do mouse.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -328,9 +312,9 @@ moves to the location of the target element and then releases the mouse.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Drag and Drop by Offset
+## Arrastar e Soltar pelo Deslocamento
 
-This method firstly performs a click-and-hold on the source element, moves to the given offset and then releases the mouse.
+Este método primeiro realiza um clique e mantém pressionado no elemento de origem, move para o deslocamento fornecido e, em seguida, libera o botão do mouse.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
diff --git a/website_and_docs/content/documentation/webdriver/actions_api/pen.pt-br.md b/website_and_docs/content/documentation/webdriver/actions_api/pen.pt-br.md
index b3f7d6112ea..efc25c947b2 100644
--- a/website_and_docs/content/documentation/webdriver/actions_api/pen.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/actions_api/pen.pt-br.md
@@ -1,22 +1,20 @@
 ---
-title: "Pen actions"
-linkTitle: "Pen"
+title: "Ações de Caneta"
+linkTitle: "Caneta"
 weight: 5
 description: >
-  A representation of a pen stylus kind of pointer input for interacting with a web page.
+  Uma representação de uma entrada de ponteiro do tipo caneta stylus para interagir com uma página da web.
 ---
 
 {{< badge-browser browser=Chromium wpt="perform_actions/pointer.py" >}}
+Uma caneta é um tipo de entrada de ponteiro que possui a maior parte do mesmo comportamento que um mouse, mas também pode ter propriedades de evento únicas para uma caneta stylus. Além disso, enquanto um mouse possui 5 botões, uma caneta possui 3 estados equivalentes de botão:
 
-A Pen is a type of pointer input that has most of the same behavior as a mouse, but can
-also have event properties unique to a stylus. Additionally, while a mouse
-has 5 buttons, a pen has 3 equivalent button states:
+* 0 — Contato por Toque (o padrão; equivalente a um clique com o botão esquerdo)
+* 2 — Botão do Barril (equivalente a um clique com o botão direito)
+* 5 — Botão de Borracha (atualmente não suportado pelos drivers)
 
-* 0 — Touch Contact (the default; equivalent to a left click)
-* 2 — Barrel Button (equivalent to a right click)
-* 5 — Eraser Button (currently unsupported by drivers)
 
-## Using a Pen
+## Usando uma Caneta
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -42,7 +40,7 @@ has 5 buttons, a pen has 3 equivalent button states:
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Adding Pointer Event Attributes
+## Adicionando Atributos de Evento de Ponteiro
 
 {{< badge-version version="4.2" >}}
 
diff --git a/website_and_docs/content/documentation/webdriver/actions_api/wheel.pt-br.md b/website_and_docs/content/documentation/webdriver/actions_api/wheel.pt-br.md
index 5cdf11828e6..72834952f36 100644
--- a/website_and_docs/content/documentation/webdriver/actions_api/wheel.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/actions_api/wheel.pt-br.md
@@ -1,26 +1,23 @@
 ---
-title: "Scroll wheel actions"
-linkTitle: "Wheel"
+title: "Ações de Roda de Rolagem"
+linkTitle: "Roda"
 weight: 6
 description: >
-    A representation of a scroll wheel input device for interacting with a web page.
+    "Uma representação de um dispositivo de entrada de roda de rolagem para interagir com uma página da web."
 ---
 
 {{< badge-version version="4.2" >}}
 {{< badge-browser browser=Chromium wpt="perform_actions/wheel.py" >}}
 
-There are 5 scenarios for scrolling on a page.
+Existem 5 cenários para rolagem em uma página.
 
-## Scroll to element
+## Rolagem até o Elemento
 
-This is the most common scenario. Unlike traditional click and send keys methods,
-the actions class does not automatically scroll the target element into view,
-so this method will need to be used if elements are not already inside the viewport.
+Este é o cenário mais comum. Diferentemente dos métodos tradicionais de clique e envio de teclas, a classe de ações não rolará automaticamente o elemento de destino para a visualização, portanto, este método precisará ser usado se os elementos não estiverem dentro da janela de visualização.
 
-This method takes a web element as the sole argument.
+Este método recebe um elemento da web como único argumento.
 
-Regardless of whether the element is above or below the current viewscreen,
-the viewport will be scrolled so the bottom of the element is at the bottom of the screen.
+Independentemente de o elemento estar acima ou abaixo da tela de visualização atual, a janela de visualização será rolada de forma que a parte inferior do elemento esteja na parte inferior da tela.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -43,10 +40,9 @@ the viewport will be scrolled so the bottom of the element is at the bottom of t
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Scroll by given amount
+## Rolar por uma Quantidade Especificada
 
-This is the second most common scenario for scrolling. Pass in an delta x and a delta y value for how much to scroll
-in the right and down directions. Negative values represent left and up, respectively.
+Este é o segundo cenário mais comum para a rolagem. Passe um valor delta x e um valor delta y para o quanto rolar nas direções direita e para baixo. Valores negativos representam esquerda e para cima, respectivamente.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -69,17 +65,13 @@ in the right and down directions. Negative values represent left and up, respect
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Scroll from an element by a given amount
+## Rolagem a partir de um Elemento por uma Quantidade Especificada"
 
-This scenario is effectively a combination of the above two methods.
+Este cenário é efetivamente uma combinação dos dois métodos mencionados anteriormente.
 
-To execute this use the "Scroll From" method, which takes 3 arguments.
-The first represents the origination point, which we designate as the element,
-and the second two are the delta x and delta y values.
+Para executar isso, use o método "Rolar a Partir de", que recebe 3 argumentos. O primeiro representa o ponto de origem, que designamos como o elemento, e os dois seguintes são os valores delta x e delta y.
 
-If the element is out of the viewport,
-it will be scrolled to the bottom of the screen, then the page will be scrolled by the provided
-delta x and delta y values.
+Se o elemento estiver fora da janela de visualização, ele será rolado para a parte inferior da tela e, em seguida, a página será rolada pelos valores delta x e delta y fornecidos.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -102,23 +94,15 @@ delta x and delta y values.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Scroll from an element with an offset
+## Rolagem a partir de um Elemento com um Deslocamento
 
-This scenario is used when you need to scroll only a portion of the screen, and it is outside the viewport.
-Or is inside the viewport and the portion of the screen that must be scrolled
-is a known offset away from a specific element.
+Este cenário é usado quando você precisa rolar apenas uma parte da tela que está fora da janela de visualização ou dentro da janela de visualização, mas a parte da tela que deve ser rolada está a uma distância conhecida de um elemento específico.
 
-This uses the "Scroll From" method again, and in addition to specifying the element,
-an offset is specified to indicate the origin point of the scroll. The offset is
-calculated from the center of the provided element.
+Isso utiliza novamente o método "Rolar a Partir", e além de especificar o elemento, é especificado um deslocamento para indicar o ponto de origem da rolagem. O deslocamento é calculado a partir do centro do elemento fornecido.
 
-If the element is out of the viewport,
-it first will be scrolled to the bottom of the screen, then the origin of the scroll will be determined
-by adding the offset to the coordinates of the center of the element, and finally
-the page will be scrolled by the provided delta x and delta y values.
+Se o elemento estiver fora da janela de visualização, primeiro ele será rolado até a parte inferior da tela. Em seguida, a origem da rolagem será determinada adicionando o deslocamento às coordenadas do centro do elemento, e, finalmente, a página será rolada pelos valores delta x e delta y fornecidos.
 
-Note that if the offset from the center of the element falls outside of the viewport,
-it will result in an exception.
+Observe que se o deslocamento a partir do centro do elemento estiver fora da janela de visualização, isso resultará em uma exceção.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -141,18 +125,13 @@ it will result in an exception.
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Scroll from a offset of origin (element) by given amount
+## Rolar a partir de um Deslocamento de Origem (Elemento) por uma Quantidade Especificada
 
-The final scenario is used when you need to scroll only a portion of the screen,
-and it is already inside the viewport.
+O cenário final é usado quando você precisa rolar apenas uma parte da tela que já está dentro da janela de visualização.
 
-This uses the "Scroll From" method again, but the viewport is designated instead
-of an element. An offset is specified from the upper left corner of the
-current viewport. After the origin point is determined,
-the page will be scrolled by the provided delta x and delta y values.
+Isso utiliza novamente o método "Rolar a Partir", mas a janela de visualização é designada em vez de um elemento. Um deslocamento é especificado a partir do canto superior esquerdo da janela de visualização atual. Após determinar o ponto de origem, a página será rolada pelos valores delta x e delta y fornecidos.
 
-Note that if the offset from the upper left corner of the viewport falls outside of the screen,
-it will result in an exception.
+Observe que se o deslocamento a partir do canto superior esquerdo da janela de visualização sair da tela, isso resultará em uma exceção.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
diff --git a/website_and_docs/content/documentation/webdriver/drivers/options.pt-br.md b/website_and_docs/content/documentation/webdriver/drivers/options.pt-br.md
index e16f9b83a46..2eb0dd3ee61 100644
--- a/website_and_docs/content/documentation/webdriver/drivers/options.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/drivers/options.pt-br.md
@@ -1,10 +1,10 @@
 ---
-title: "Browser Options"
+title: "Opções do navegador"
 linkTitle: "Options"
 weight: 2
 needsTranslation: true
 description: >-
-  These capabilities are shared by all browsers.
+  Esses recursos são compartilhados por todos os navegadores.
 aliases: [
 "/documentation/pt-br/driver_idiosyncrasies/shared_capabilities/",
 "/pt-br/documentation/webdriver/capabilities/shared_capabilities/",
@@ -27,45 +27,26 @@ aliases: [
 </p>
 {{% /pageinfo %}}
 
-In Selenium 3, capabilities were defined in a session by using Desired Capabilities classes.
-As of Selenium 4, you must use the browser options classes. 
-For remote driver sessions, a browser options instance is required as it determines which browser will be used.
+No Selenium 3, os recursos foram definidos em uma sessão usando classes de recursos desejados.
+A partir do Selenium 4, você deve usar as classes de opções do navegador.
+Para sessões remotas de driver, uma instância de opções do navegador é necessária, pois determina qual navegador será usado.
 
-These options are described in the w3c specification for [Capabilities](https://w3c.github.io/webdriver/#capabilities).
+Essas opções são descritas na especificação w3c para [Capabilities](https://w3c.github.io/webdriver/#capabilities).
 
-Each browser has [custom options]({{< ref "../browsers/" >}}) that may be defined in addition to the ones defined in the specification.
+Cada navegador tem [custom options]({{< ref "../browsers/" >}}) que podem ser definidas além das definidas na especificação.
 
 ## browserName
 
-Browser name is set by default when using an Options class instance.
-
-{{< tabpane text=true langEqualsHeader=true >}}
-{{< tab header="Java" >}}
-{{< badge-code >}}
-{{< /tab >}}
-{{% tab header="Python" %}}
-{{< badge-code >}}
-{{% /tab %}}
-{{< tab header="CSharp" >}}
-{{< badge-code >}}
-{{< /tab >}}
-{{< tab header="Ruby" >}}
-{{< badge-code >}}
-{{< /tab >}}
-{{< tab header="JavaScript" >}}
-{{< badge-code >}}
-{{< /tab >}}
-{{< tab header="Kotlin" >}}
-{{< badge-code >}}
-{{< /tab >}}
-{{< /tabpane >}}
-
+Esta capacidade é usada para definir o `browserName` para uma determinada sessão.
+Se o navegador especificado não estiver instalado no
+extremidade remota, a criação da sessão falhará.
 
 ## browserVersion
 
-This capability is optional, this is used to set the available browser version at remote end.
-In recent versions of Selenium, if the version is not found on the system,
-it will be automatically downloaded by [Selenium Manager]({{< ref "../../selenium_manager" >}})
+Esta capacidade é opcional, é usada para
+defina a versão do navegador disponível na extremidade remota.
+Por exemplo, se solicitar o Chrome versão 75 em um sistema que
+tiver apenas 80 instalados, a criação da sessão falhará.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -91,31 +72,31 @@ it will be automatically downloaded by [Selenium Manager]({{< ref "../../seleniu
 
 ## pageLoadStrategy
 
-Three types of page load strategies are available.
+Três tipos de estratégias de carregamento de página estão disponíveis.
 
-The page load strategy queries the 
+A estratégia de carregamento da página consulta o
 [document.readyState](//developer.mozilla.org/en-US/docs/Web/API/Document/readyState)
-as described in the table below:
+conforme descrito na tabela abaixo:
 
-| Strategy | Ready State | Notes |
+| Estratégia | Estado pronto | Notas |
 | -------- | ----------- | ----- |
-| normal | complete | Used by default, waits for all resources to download |
-| eager | interactive | DOM access is ready, but other resources like images may still be loading |
-| none | Any | Does not block WebDriver at all |
-
-The `document.readyState` property of a document describes the loading state of the current document.
-
-When navigating to a new page via URL, by default, WebDriver will hold off on completing a navigation 
-method (e.g., driver.navigate().get()) until the document ready state is complete. This _does not 
-necessarily mean that the page has finished loading_, especially for sites like Single Page Applications 
-that use JavaScript to dynamically load content after the Ready State returns complete. Note also 
-that this behavior does not apply to navigation that is a result of clicking an element or submitting a form.
-
-If a page takes a long time to load as a result of downloading assets (e.g., images, css, js) 
-that aren't important to the automation, you can change from the default parameter of `normal` to
-`eager` or `none` to speed up the session. This value applies to the entire session, so make sure 
-that your [waiting strategy]({{< ref "/documentation/webdriver/waits.md" >}}) is sufficient to minimize 
-flakiness.
+| normal | completo | Usado por padrão, aguarda o download de todos os recursos |
+| ansioso | interativo | O acesso DOM está pronto, mas outros recursos como imagens ainda podem estar carregando |
+| nenhum | Qualquer | Não bloqueia o WebDriver |
+
+A propriedade `document.readyState` de um documento descreve o estado de carregamento do documento atual.
+
+Ao navegar para uma nova página via URL, por padrão, o WebDriver irá adiar a conclusão de uma navegação
+(por exemplo, driver.navigate().get()) até que o estado pronto do documento seja concluído. isso _não
+significa necessariamente que a página terminou de carregar_, especialmente para sites como Single Page Applications
+que usam JavaScript para carregar conteúdo dinamicamente depois que o estado Pronto retorna completo. Observe também
+que esse comportamento não se aplica à navegação resultante de clicar em um elemento ou enviar um formulário.
+
+Se uma página demorar muito para carregar como resultado do download de ativos (por exemplo, imagens, css, js)
+que não são importantes para a automação, você pode mudar do parâmetro padrão de `normal` para
+`eager` ou `none` para acelerar a sessão. Esse valor se aplica a toda a sessão, portanto, certifique-se
+que sua [waiting strategy]({{< ref "/documentation/webdriver/waits.md" >}}) é suficiente para minimizar
+descamação.
 
 
 ### normal (default)
diff --git a/website_and_docs/content/documentation/webdriver/getting_started/using_selenium.pt-br.md b/website_and_docs/content/documentation/webdriver/getting_started/using_selenium.pt-br.md
index f1d08996f5e..ebcc16ed09a 100644
--- a/website_and_docs/content/documentation/webdriver/getting_started/using_selenium.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/getting_started/using_selenium.pt-br.md
@@ -1,43 +1,43 @@
 ---
-title: "Organizing and Executing Selenium Code"
-linkTitle: "Using Selenium"
+title: "Organizando e executando o código Selenium"
+linkTitle: "Utilizando o Selenium"
 weight: 10
 description: >
-    Scaling Selenium execution with an IDE and a Test Runner library
+    Escalonamento da execução do Selenium com um IDE e uma biblioteca do Test Runner
 ---
 
-If you want to run more than a handful of one-off scripts, you need to 
-be able to organize and work with your code. This page should give you
-ideas for how to actually do productive things with your Selenium code.
+Se quiser executar mais do que um punhado de scripts pontuais, precisa de 
+ser capaz de organizar e trabalhar com seu código. Esta página deve dar a você
+ideias de como fazer coisas produtivas com seu código Selenium.
 
-## Common Uses
+## Usos comuns
 
-Most people use Selenium to execute automated tests for web applications, 
-but Selenium support any use case of browser automation.
+A maioria das pessoas usa o Selenium para executar testes automatizados para aplicações web, 
+mas o Selenium suporta qualquer caso de uso de automação de navegador.
 
-### Repetitive Tasks
+### Tarefas Repetitivas
 
-Perhaps you need to log into a website and download something, or submit a form.
-You can create a Selenium script to run with a service at preset times.
+Talvez seja necessário fazer login em um site e baixar algo ou enviar um formulário.
+Você pode criar um script Selenium para ser executado com um serviço em horários pré-definidos.
 
-### Web Scraping
+### Web Scrapping
 
-Are you looking to collect data from a site that doesn't have an API? Selenium
-will let you do this, but please make sure you are familiar with the website's
-terms of service as some websites do not permit it and others will even block Selenium.
+Está a tentar recolher dados de um site que não tem uma API? O Selenium
+permitirá que você faça isso, mas certifique-se de estar familiarizado com os termos de serviço do site
+termos de serviço do site, pois alguns sites não permitem isso e outros até bloqueiam o Selenium.
 
-### Testing
+### Testes
 
-Running Selenium for testing requires making assertions on actions taken by Selenium.
-So a good assertion library is required. Additional features to provide structure for tests
-require use of [Test Runner](#test-runners).
+Executar o Selenium para testes requer fazer asserções sobre as ações tomadas pelo Selenium.
+Então uma boa biblioteca de asserções é necessária. Características adicionais para prover estrutura para testes
+requerem o uso de [Test Runner] (#test-runners).
 
 
 ## IDEs
 
-Regardless of how you use Selenium code, 
-you won't be very effective writing or executing it without a good
-Integrated Developer Environment. Here are some common options...
+Independentemente de como você usa o código do Selenium, 
+não será muito eficaz escrevendo ou executando-o sem um bom
+ambiente de desenvolvimento integrado. Aqui estão algumas opções comuns...
 
 - [Eclipse](https://www.eclipse.org/)
 - [IntelliJ IDEA](https://www.jetbrains.com/idea/)
@@ -47,44 +47,44 @@ Integrated Developer Environment. Here are some common options...
 - [WebStorm](https://www.jetbrains.com/webstorm/)
 - [VS Code](https://code.visualstudio.com/)
 
-## Test Runner
+## Executador de teste
 
-Even if you aren't using Selenium for testing, if you have advanced use cases, it might make
-sense to use a test runner to better organize your code. Being able to use before/after hooks 
-and run things in groups or in parallel can be very useful.
+Mesmo que não esteja a usar o Selenium para testes, se tiver casos de uso avançado, pode fazer
+sentido usar um executor de testes para organizar melhor seu código. Ser capaz de usar hooks antes/depois 
+e executar coisas em grupos ou em paralelo pode ser muito útil.
 
-### Choosing
-There are many different test runners available.
+### Escolhendo
+Há muitos executores de teste diferentes disponíveis.
 
-All the code examples in this documentation can be found in (or is being moved to) our
-example directories that use test runners and get executed every release to ensure all the code is correct and updated.
-Here is a list of test runners with links. The first item is the one that is used by this repository and the one
-that will be used for all examples on this page.
+Todos os exemplos de código nesta documentação podem ser encontrados em (ou estão sendo movidos para) nossos diretórios
+que usam test runners e são executados a cada lançamento para garantir que todo o código esteja correto e atualizado.
+Aqui está uma lista de executores de teste com links. O primeiro item é o que é usado por este repositório e o que
+que será usado para todos os exemplos nesta página.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{% tab header="Java" %}}
-- [JUnit](https://junit.org/junit5/) - A widely-used testing framework for Java-based Selenium tests.
-- [TestNG](https://testng.org/doc/) - Offers extra features like parallel test execution and parameterized tests.
+- [JUnit](https://junit.org/junit5/) - Uma estrutura de teste amplamente utilizada para testes Selenium baseados em Java.
+- [TestNG](https://testng.org/doc/) - Oferece recursos extras, como execução de testes paralelos e testes parametrizados.
 {{% /tab %}}
 
 {{% tab header="Python" %}}
-- [pytest](https://pytest.org/) - A preferred choice for many, thanks to its simplicity and powerful plugins.
-- [unittest](https://docs.python.org/3/library/unittest.html) - Python's standard library testing framework.
+- [pytest](https://pytest.org/) -Uma escolha preferida por muitos, graças à sua simplicidade e aos seus poderosos plugins.
+- [unittest](https://docs.python.org/3/library/unittest.html) - A estrutura de testes da biblioteca padrão do Python.
 {{% /tab %}}
 
 {{% tab header="CSharp" %}}
-- [NUnit](https://nunit.org/) - A popular unit-testing framework for .NET.
-- [MS Test](https://docs.microsoft.com/en-us/visualstudio/test/getting-started-with-unit-testing?view=vs-2019) - Microsoft's own unit testing framework.
+- [NUnit](https://nunit.org/) - Um popular framework de teste unitário para .NET.
+- [MS Test](https://docs.microsoft.com/en-us/visualstudio/test/getting-started-with-unit-testing?view=vs-2019) - O Framework de testes unitários da Microsoft.
 {{% /tab %}}
 
 {{% tab header="Ruby" %}}
-- [RSpec](https://rspec.info/) - The most widely used testing library for running Selenium tests in Ruby.
-- [Minitest](https://github.com/seattlerb/minitest) - A lightweight testing framework that comes with Ruby standard library.
+- [RSpec](https://rspec.info/) - A biblioteca de testes mais utilizada para executar testes Selenium em Ruby.
+- [Minitest](https://github.com/seattlerb/minitest) - Um framework de testes leve que vem com a biblioteca padrão do Ruby.
 {{% /tab %}}
 
 {{% tab header="JavaScript" %}}
-- [Jest](https://jestjs.io/) - Primarily known as a testing framework for React, it can also be used for Selenium tests.
-- [Mocha](https://mochajs.org/) - The most common JS library for running Selenium tests.
+- [Jest](https://jestjs.io/) - Principalmente conhecido como um framework de teste para React, também pode ser utilizado para testes Selenium.
+- [Mocha](https://mochajs.org/) - A biblioteca JS mais comum para executar testes Selenium.
 {{% /tab %}}
 
 {{% tab header="Kotlin" %}}
@@ -93,10 +93,10 @@ that will be used for all examples on this page.
 {{< /tabpane >}}
 
 
-### Installing
+### Instalando
 
-This is very similar to what was required in [Install a Selenium Library]({{< ref "install_library.md" >}}).
-This code is only showing examples for what is being used in our Documentation Examples project.
+Isto é muito semelhante ao que foi requerido em [Install a Selenium Library]({{< ref "install_library.md" >}}).
+Este código está apenas a mostrar exemplos do que está a ser usado no nosso projeto de Exemplos de Documentação.
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{% tab header="Java" %}}
@@ -108,11 +108,11 @@ This code is only showing examples for what is being used in our Documentation E
 {{% /tab %}}
 {{% tab header="Python" %}}
 
-To use it in a project, add it to the `requirements.txt` file:
+Para usá-lo em um projeto, adicione-o ao arquivo `requirements.txt`:
 
 {{% /tab %}}
 {{% tab header="CSharp" %}}
-in the project's `csproj` file, specify the dependency as a `PackageReference` in `ItemGroup`:
+in the project's `csproj` especifique a dependência como `PackageReference` em `ItemGroup`:
 
 {{% /tab %}}
 {{% tab header="Ruby" %}}
@@ -121,14 +121,14 @@ Add to project's gemfile
 
 {{% /tab %}}
 {{% tab header="JavaScript" %}}
-In your project's `package.json`, add requirement to `dependencies`:
+In your project's `package.json`, adicionar requisito às `dependências`:
 
 {{% /tab %}}
 {{< tab header="Kotlin" >}}
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Asserting
+### Afirmar
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -151,7 +151,7 @@ In your project's `package.json`, add requirement to `dependencies`:
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Setting Up and Tearing Down
+### Configuarar e Desconfigurar
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{< tab header="Java" >}}
@@ -174,7 +174,7 @@ In your project's `package.json`, add requirement to `dependencies`:
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Executing
+### Executando
 
 {{< tabpane text=true langEqualsHeader=true >}}
 {{% tab header="Java" %}}
@@ -210,7 +210,7 @@ mocha runningTests.spec.js
 {{< /tab >}}
 {{< /tabpane >}}
 
-### Examples
+### Examplos
 
 In [First script]({{< ref "first_script.md" >}}), we saw each of the components of a Selenium script.
 Here's an example of that code using a test runner:
@@ -236,9 +236,9 @@ Here's an example of that code using a test runner:
 {{< /tab >}}
 {{< /tabpane >}}
 
-## Next Steps
+## Proximos passos
 
-Take what you've learned and build out your Selenium code! 
+Pegue no que aprendeu e desenvolva o seu código Selenium!
 
-As you find more functionality that you need, read up on the rest of our
-[WebDriver documentation]({{< ref "/documentation/webdriver/" >}}).
+À medida que encontrar mais funcionalidades de que precisa, leia o resto da nossa
+[documentação do WebDriver]({{< ref "/documentation/webdriver/" >}}).
diff --git a/website_and_docs/content/documentation/webdriver/support_features/_index.pt-br.md b/website_and_docs/content/documentation/webdriver/support_features/_index.pt-br.md
index 81bcf578753..d5c814a0a55 100644
--- a/website_and_docs/content/documentation/webdriver/support_features/_index.pt-br.md
+++ b/website_and_docs/content/documentation/webdriver/support_features/_index.pt-br.md
@@ -1,9 +1,9 @@
 ---
-title: "Support Features"
-linkTitle: "Support Features"
+title: "Recursos de suporte"
+linkTitle: "Recursos de suporte"
 weight: 18
 description: >
-  Support classes provide optional higher level features.
+ As classes de suporte fornecem características opcionais de nível superior.
 aliases: [
 "/documentation/pt-br/support_packages/",
 "/pt-br/documentation/support_packages/",
@@ -11,6 +11,6 @@ aliases: [
 ]
 ---
 
-The core libraries of Selenium try to be low level and non-opinionated.
-The Support classes in each language provide opinionated wrappers for common interactions
-that may be used to simplify some behaviors.
+As bibliotecas principais do Selenium tentam ser de baixo nível e não opinativas.
+As classes de suporte em cada linguagem fornecem invólucros opinativos para interações comuns
+que podem ser usadas para simplificar alguns comportamentos.