0
# Selenium DevTools v138
1
2
Chrome DevTools Protocol (CDP) bindings for Selenium WebDriver version 138, enabling low-level browser interaction and automation beyond standard WebDriver capabilities. This package provides Java bindings that allow developers to interact with Chrome/Chromium browsers through the DevTools interface for advanced debugging, monitoring, and automation scenarios.
3
4
## Package Information
5
6
- **Package Name**: org.seleniumhq.selenium:selenium-devtools-v138
7
- **Package Type**: Maven
8
- **Language**: Java
9
- **Version**: 4.35.0
10
- **Installation**: Add to your Maven dependencies:
11
12
```xml
13
<dependency>
14
<groupId>org.seleniumhq.selenium</groupId>
15
<artifactId>selenium-devtools-v138</artifactId>
16
<version>4.35.0</version>
17
</dependency>
18
```
19
20
## Core Imports
21
22
```java
23
import org.openqa.selenium.devtools.v138.*;
24
import org.openqa.selenium.devtools.DevTools;
25
import org.openqa.selenium.chrome.ChromeDriver;
26
```
27
28
For specific domains:
29
30
```java
31
import org.openqa.selenium.devtools.v138.v138Domains;
32
import org.openqa.selenium.devtools.v138.v138Events;
33
import org.openqa.selenium.devtools.v138.v138Javascript;
34
import org.openqa.selenium.devtools.v138.v138Network;
35
import org.openqa.selenium.devtools.v138.v138Log;
36
import org.openqa.selenium.devtools.v138.v138Target;
37
```
38
39
For public API usage:
40
41
```java
42
import java.util.function.Consumer;
43
import java.util.function.Predicate;
44
import java.util.function.Supplier;
45
import org.openqa.selenium.Credentials;
46
```
47
48
## Basic Usage
49
50
```java
51
import org.openqa.selenium.chrome.ChromeDriver;
52
import org.openqa.selenium.devtools.DevTools;
53
import org.openqa.selenium.devtools.v138.v138Domains;
54
55
// Create Chrome driver and get DevTools
56
ChromeDriver driver = new ChromeDriver();
57
DevTools devTools = driver.getDevTools();
58
59
// Create and use v138 domains
60
devTools.createSession();
61
v138Domains domains = new v138Domains(devTools);
62
63
// Enable console logging
64
devTools.send(domains.log().enable());
65
66
// Listen for console events (using Events domain)
67
domains.events().addConsoleListener(console ->
68
System.out.println("Console " + console.getType() + ": " +
69
console.getArgs().get(0)));
70
71
// Navigate to a page
72
driver.get("https://example.com");
73
74
// Clean up
75
devTools.close();
76
driver.quit();
77
```
78
79
## Architecture
80
81
The v138 package implements Chrome DevTools Protocol version 138 through a layered architecture:
82
83
- **Service Registration**: `v138CdpInfo` provides automatic version discovery via Java ServiceLoader
84
- **Domain Aggregation**: `v138Domains` serves as the main entry point, providing access to all CDP domains
85
- **Specialized Domains**: Individual domain implementations (`v138Network`, `v138Javascript`, etc.) wrap generated CDP classes
86
- **Protocol Abstraction**: All classes implement idealized interfaces from `org.openqa.selenium.devtools.idealized.*`
87
- **Version Compatibility**: Designed for Chrome version 138 with backward/forward compatibility within a 5-version range
88
89
## Capabilities
90
91
### Domain Management
92
93
Main entry point providing access to all Chrome DevTools Protocol domains. Essential for initializing and coordinating CDP functionality.
94
95
```java { .api }
96
public class v138Domains implements Domains {
97
public v138Domains(DevTools devtools);
98
public Events<?, ?> events();
99
public Javascript<?, ?> javascript();
100
public Network<?, ?> network();
101
public Target target();
102
public Log log();
103
}
104
```
105
106
[Domain Management](./domain-management.md)
107
108
### Runtime Events and Console
109
110
Runtime events handling and console monitoring capabilities. Enables capturing JavaScript exceptions, console messages, and runtime diagnostics.
111
112
```java { .api }
113
public class v138Events extends Events<ConsoleAPICalled, ExceptionThrown> {
114
public v138Events(DevTools devtools);
115
protected Event<ConsoleAPICalled> consoleEvent();
116
protected Event<ExceptionThrown> exceptionThrownEvent();
117
protected ConsoleEvent toConsoleEvent(ConsoleAPICalled event);
118
protected JavascriptException toJsException(ExceptionThrown event);
119
}
120
```
121
122
[Runtime Events](./runtime-events.md)
123
124
### JavaScript Execution and Binding
125
126
JavaScript execution environment management and bidirectional communication setup. Provides script injection, binding management, and page-level script control.
127
128
```java { .api }
129
public class v138Javascript extends Javascript<ScriptIdentifier, BindingCalled> {
130
public v138Javascript(DevTools devtools);
131
protected Command<ScriptIdentifier> addScriptToEvaluateOnNewDocument(String script);
132
protected Command<Void> removeScriptToEvaluateOnNewDocument(ScriptIdentifier id);
133
protected Command<Void> doAddJsBinding(String scriptName);
134
protected Command<Void> doRemoveJsBinding(String scriptName);
135
}
136
```
137
138
[JavaScript Integration](./javascript-integration.md)
139
140
### Network Monitoring and Interception
141
142
Network traffic monitoring, request/response interception, and authentication handling. Essential for API testing, performance monitoring, and request modification.
143
144
```java { .api }
145
public class v138Network extends Network<AuthRequired, RequestPaused> {
146
public v138Network(DevTools devTools);
147
protected Command<Void> setUserAgentOverride(UserAgent userAgent);
148
protected Command<Void> enableNetworkCaching();
149
protected Command<Void> disableNetworkCaching();
150
protected Event<AuthRequired> authRequiredEvent();
151
protected Event<RequestPaused> requestPausedEvent();
152
public Either<HttpRequest, HttpResponse> createSeMessages(RequestPaused pausedReq);
153
}
154
```
155
156
[Network Operations](./network-operations.md)
157
158
### Console Logging
159
160
Console log management and event streaming. Provides access to browser console output with level filtering and timestamp conversion.
161
162
```java { .api }
163
public class v138Log implements org.openqa.selenium.devtools.idealized.log.Log {
164
public Command<Void> enable();
165
public Command<Void> clear();
166
public Event<LogEntry> entryAdded();
167
}
168
```
169
170
[Console Logging](./console-logging.md)
171
172
### Target Management
173
174
Browser target (tab/window) management and session control. Enables working with multiple browser contexts and coordinating cross-target operations.
175
176
```java { .api }
177
public class v138Target implements org.openqa.selenium.devtools.idealized.target.Target {
178
public Command<List<TargetInfo>> getTargets();
179
public Command<SessionID> attachToTarget(TargetID targetId);
180
public Command<Void> detachFromTarget(Optional<SessionID> sessionId, Optional<TargetID> targetId);
181
public Command<Void> setAutoAttach();
182
public Event<TargetID> detached();
183
}
184
```
185
186
[Target Management](./target-management.md)
187
188
### Version Registration
189
190
Service registration for automatic CDP version discovery. Handles integration with Selenium's version selection mechanism.
191
192
```java { .api }
193
@AutoService(CdpInfo.class)
194
public class v138CdpInfo extends CdpInfo {
195
public v138CdpInfo();
196
}
197
```
198
199
[Version System](./version-system.md)
200
201
## Types
202
203
```java { .api }
204
// Core DevTools integration
205
interface Domains {
206
Events<?, ?> events();
207
Javascript<?, ?> javascript();
208
Network<?, ?> network();
209
Target target();
210
Log log();
211
}
212
213
// Command pattern for CDP operations
214
interface Command<T> {
215
String getMethod();
216
Map<String, Object> getParams();
217
}
218
219
// Event streaming for CDP notifications
220
interface Event<T> {
221
String getMethod();
222
Function<JsonInput, T> map();
223
}
224
225
// Network interception types
226
class UserAgent {
227
String userAgent();
228
String acceptLanguage();
229
String platform();
230
}
231
232
// Target management types
233
class TargetInfo {
234
TargetID getTargetId();
235
String getType();
236
String getTitle();
237
String getUrl();
238
Boolean getAttached();
239
Optional<TargetID> getOpenerId();
240
}
241
242
class SessionID {
243
String toString();
244
}
245
246
class TargetID {
247
String toString();
248
}
249
250
// Console and logging types
251
class ConsoleEvent {
252
String getType();
253
Instant getTimestamp();
254
List<Object> getArgs();
255
}
256
257
class LogEntry {
258
String getSource();
259
org.openqa.selenium.logging.LogEntry getEntry();
260
}
261
262
// Functional interfaces for API methods
263
@FunctionalInterface
264
interface Consumer<T> {
265
void accept(T t);
266
}
267
268
@FunctionalInterface
269
interface Predicate<T> {
270
boolean test(T t);
271
}
272
273
@FunctionalInterface
274
interface Supplier<T> {
275
T get();
276
}
277
278
@FunctionalInterface
279
interface Filter {
280
boolean test(HttpRequest request);
281
}
282
283
// Authentication types
284
class Credentials {
285
Credentials(String username, String password);
286
String getUsername();
287
String getPassword();
288
}
289
290
// Script management types
291
class ScriptId {
292
String toString(); // Unique identifier for pinned scripts
293
}
294
```