safari xpath

Evaluate XPath to find elements in the page

DevTools supports 2 ways to evaluate XPath expressions to help you locate elements in the page. All browsers support those 2 ways:

• Click anywhere in the panel to make sure it has focus
• Press ctrl + F (or cmd + F on Mac) to focus the search field
• Enter your XPath expression and press enter to find the elements that match

Note that you can also copy the XPath expression from any element in DevTools .

• You can use the built-in $x() helper function like this:

Last edit: 10/29/2021 - Edit this page

Xpath cheatsheet

Xpath test bed.

Test queries in the Xpath test bed:

• Xpath test bed (whitebeam.org)

Browser console

Works in Firefox and Chrome.

Descendant selectors

Attribute selectors, order selectors, other things, class check.

Xpath doesn’t have the “check if part of space-separated list” operator, so this is the workaround ( source ).

Expressions

Steps and axes.

Begin your expression with any of these.

Separate your steps with / . Use two ( // ) if you don’t want to select direct children.

A step may have an element name ( div ) and predicates ( [...] ). Both are optional. They can also be these other things:

Restricts a nodeset only if some condition is true. They can be chained.

Use comparison and logic operators to make conditionals.

Using nodes

You can use nodes inside predicates.

Use [] with a number, or last() or position() .

Chaining order

Order is significant, these two are different.

Nesting predicates

This returns <section> if it has an <h1> descendant with id='hi' .

Node functions

Boolean functions, string functions, type conversion.

Steps of an expression are separated by / , usually used to pick child nodes. That’s not always true: you can specify a different “axis” with :: .

child:: is the default axis. This makes //a/b/c work.

Descendant-or-self axis

// is short for the descendant-or-self:: axis.

There are other axes you can use.

Use | to join two expressions.

More examples

Find a parent.

Finds a <section> that directly contains h1#section-name

Finds a <section> that contains h1#section-name . (Same as above, but uses descendant-or-self instead of child)

Works like jQuery’s $().closest('.box') .

Finds <item> and check its attributes

NetLicensing stands with our friends, colleagues, and family members in Ukraine, and with all the people of Ukraine! Willing to help too? Click here.

How to evaluate and validate XPath and CSS selectors

• Oct 12, 2020
•  by GuideChimp

There are many scenarios where developers need a valid XPath/CSS selector definition.

For instance, JavaScript configuration for GuideChimp tours needs a valid element selector, which will be used to highlight an HTML/DOM element or place a beacon.

What is the easiest way to validate XPath / CSS selectors?

Most of the browsers provide a built-in developer tools, which includes a handy feature that can evaluate or validate XPath/CSS selectors without any third-party extensions: browser console .

Step-by-step instructions:

• Open page containing HTML/DOM you would need to verify selector on; in our example, we’ll be using netlicensing.io/licensing-models page
• Chrome, Firefox: press F12
• Safari: use the shortcut Option + ⌘ + J (on macOS), or Shift + CTRL + J (on Windows/Linux)
• Switch to Console tab
• Type in XPath or CSS selectors to evaluate like:

If there are matched elements, the console output will contain a matched DOM element; otherwise null , undefined or an exception will be thrown if the locator is invalid or doesn’t exist.

Most of the browser will even highlight HTML element on mouse hover over the console output.

Having all CSS selectors properly defined, GuideChimp will show an interactive guided tour for your website or application.

Related Posts

Easily update customers’ entitlements

The Worst Nightmares for Account Managers

What is authentication-authorization-validation framework.

Infographic: How To Select Licensing Model

Onboard users using interactive Product Tours with GuideChimp

How to Find XPath to Locate Data in a Web Page

XPath expressions help you easily navigate XML/HTML documents. As you may notice, web scraping is all about parsing through HTML documents. In this regard, XPath is quite handy in web scraping projects as it enables you to programmatically access HTML elements, locate data, and extract useful data. CSS selectors are one of the XPath alternatives, but XPaths are far more versatile than CSS selectors when it comes to navigating the DOM (document object model). Read this insight to understand:

• XPath in detail,
• Its significance in the web scraping world,
• How to find XPath if you’ve no prior knowledge of XPath, 
• A few basics of XPath, so that you can write your own. 

Let’s get started.

What is XPath?

XPath stands for XML path language. Visually, it looks like a URI. From a conceptual angle, it is very similar to real-world navigational instructions. Ever found yourself globetrotting from one location to another on Google or Apple Maps? If you have, you would know these apps instruct you to take left/right after XYZ meters . But how do people instruct when you don’t have access to Maps and don’t know the route either? Their instructions look like this: keep going straight and take the first left after Dominos. While the apps give you absolutely [take left after 200 meters] navigational paths, real people give you relative [take right after Zara store] navigational paths . XPaths too are of two types. Can you guess them? Yes, absolute XPaths and relative XPaths .

That was a casual introduction to XPath. In technical lingo, Xpath is a path language used to locate a node or nodes in an XML or an HTML file. It is not complicated like a programming language but has a set of grammatical rules to write paths that traverse the DOM to access certain content on the web page.

It is especially useful for web scraping . We use Xpath to locate data in web scraping. It’s a must-learn skill if you are extracting data from web pages. If you are getting data from websites with a tricky structure, Xpath knowledge can save your day! Nothing explains better than a hands-on experience. For demonstrating and helping you understand let’s analyze the DOM of Levi’s website.

You can open this in a browser of your choice: Chrome, Edge, Firefox, Safari, UC Browser, etcetera. Bring the “developer tools” on the screen. In Chrome, you can do this easily by pressing “ Ctrl + Shift + i ”, or by right-clicking your mouse and choosing to inspect the element .​

Doing so will pop up a developer tools screen with “Elements” as the active tab. This tab shows you the source code for the active web page. You can move your cursor over the HTML tags and observe the highlighted sections on the webpage. Each of these tags can be considered a node and it can comprise zero to multiple child nodes. XPath is a syntax that helps us navigate through these HTML nodes.

Now, just for a demo – I’ll write an XPath to access these recommended jeans on Levi’s website. In Chrome, you can press the keys “CTRL + F” to fire up a search bar within the developer tools panel. Observe it at the bottom. In Firefox, it’s active by default at the top.

In this search bar, you can write and validate any XPath. Observe how the HTML node for the first recommended Jeans got highlighted when I wrote an XPath for it in the search bar. Hovering over the highlighted node also highlights the Jeans HTML component on the web page. 

How XPath Helps in Web Scraping  

Think of a scraper as your assistant. If you want him to buy you a pack of cereal, you have to explain where he can find it clearly so that he knows exactly where to grab it: which street, in which shop, and on which shelf. Xpath is the language that works as an address. For scraping HTML documents, XPath tells your scraper:

• What to scrape i.e, what data needs to be extracted, and
• From where to scrape i.e, which HTML Node will give that data?

Extending on our example above, if we need price data of the top 10 recommended products on Levi’s home page, we can write an XPath to help document parsers identify the HTML nodes containing prices. Here’s how it is done:

//div[contains(@class,”zola-carousel”)]//div[contains(@class,”price”)]

Challenges in locating data

• Say, you need to gather data across multiple pages, and the robot will repeat the same set of steps across pages to scrape the data. But the same element may be embedded in different structures on pages 1 and page 10. In this case, steps that work on page 1 may cause errors on page 10.  
• The thing is, you don’t want to confuse the robot by offering a vague address where it encounters a lot of targets. Very likely he will grab the nearest one and it may not be the one you have expected.

So writing an XPath is sensible to give the unique address to a node that contains your target data. The robot can reach exactly the data of your interest and will extract highly consistent data. Relative XPaths written using the components that are less likely to change will work for a longer period and would need less maintenance. For example, I would prefer using contains[text(),”$”] over @class=”price” as identifiers, if both serve the purpose.

Why Should You Use XPath For Web Scraping?

I can nullify the following reasons to use XPaths for building robust web scrapers:

• Helps you reach any visible, or non-visible node, or a collection of nodes on a web page i.e., an XML document. In the above Levi’s example, we accessed 10 price nodes i.e., a collection using a single XPath.
• XPath expressions can be used in PHP, Python, Java, Javascript, C, and C++.
• It is a W3C norm and has 200 built-in functions to access numeric values, and boolean values, for comparing date and time values, and for node manipulation too.
• XPath can access 7 types of DOM components: HTML elements or nodes, attributes, namespaces, comments, text, processing instructions, and document nodes.
• Xpath can traverse a web page in any direction. It can also leverage the relationships between nodes to navigate the DOM i.e., you can write XPaths to find parents, siblings, Descendants, ancestors, etcetera of a node.
• Relative XPaths can be very effective even if the website structure changes.
• XPaths can start either from the root node i.e., / or it can start from any node // . You have functions like position(), last(), etcetera that you can append as predicate and use along with operators like <, >, <=, +, -, div, etcetera to selectively access/extract data from the web page.

Learn more about writing XPaths here .

Octoparse’s workarounds

Octoparse is committed to making Web Scraping easier, faster, and better, especially for non-coders. They can get web data just as programmers do.

• Auto-detection feature

Octoparse uses AI to intelligently detect useful data on the web page. The feature is called the auto-detect function and is available from Octoparse version 8 onwards. The auto-detect feature has been very successful and effective in detecting tables, infinite scrolls, loading more, listing data, and several other web design paradigms.

Steps to use Octoparse’s auto-detect feature for web scraping Amazon.com:

• Enter the URL on the home screen after logging into the Octoparse tool.
• Click on “Start” and then “auto-detect web page data”.
• Octoparse automatically detects data, labels it, and asks for your permission to create a workflow.
• Click on Create Workflow option in the Action Tips dialog. And BANG!!! The workflow is automatically created.

Easy-peasy! Is it not?

• Select by point and click in the built-in browser

Alternatively, if you’re using an older version of Octoparse, or if the new version 8 auto-detect function doesn’t work effectively for a website (rare case), then you can point your cursor to your target elements and choose an appropriate action in the action TIPS menu to extract the data. If you want to view or modify XPath, even that is possible.

 >> More specific guides to find Xpath with Octoparse  

How to find Xpath

If you are a total newbie and have no idea of terms like “node”, “element” and “attribute”, get yourself some basic knowledge in W3C HTML first. Here are some crash courses for XPath learning:

• OP Youtube videos

Find the right Xpath in Chrome

1. Copy Xpath in Chrome

Steps to find XPath in Chrome developer tool:

1) Fire up Chrome developer tools by inspecting an element in the DOM. You can do so by pointing your cursor to the target DOM element and then right-clicking on the target element. Next, you can select the Inspect element option from the pop-up menu.

2)  Now, again right-click on the HTML element of the target and copy the XPath. Easy!

2. Write your own with Xpath Helper

You can also write your own XPath using the XPath Helper Chrome extension. Additionally, Octoparse also has an in-built XPath tool  (available in Octoparse 7) to make things easier for you. To write your own XPath read this in-depth tutorial .  

Conclusion  

XPath is an integral part of any web scraping project. Tools like Octoparse make it easy for you to scrape the web by intelligently writing XPaths for you under the hood while you point and click at your target data. The new innovative auto-detect function of Octoparse eliminates the need to even point-&-click. For more resources on Scraping stay tuned to Octoparse on Twitter . Happy Scraping!

Explore topics

• # Web Scraping 208
• # Knowledge 118
• # Octoparse 95
• # Big Data 59
• # Data Collection 53
• # Customer Reviews 21

Get started with Octoparse today

Related articles.

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

XPath browser plugin for Safari

farcaller/safarixpath

Folders and files.

• Objective-C 100.0%

previous episode

Ucsb library library carpentry, next episode, selecting content on a web page with xpath.

Overview Teaching: 30 min Exercises: 15 min Questions How can I select a specific element on web page? What is XPath and how can I use it? Objectives Introduce XPath queries Explain the structure of an XML or HTML document Explain how to view the underlying HTML content of a web page in a browser Explain how to run XPath queries in a browser Introduce the XPath syntax Use the XPath syntax to select elements on this web page

Before we delve into web scraping proper, we will first spend some time introducing some of the techniques that are required to indicate exactly what should be extracted from the web pages we aim to scrape.

The material in this section was adapted from the XPath and XQuery Tutorial written by Kim Pham ( @tolloid ) for the July 2016 Library Carpentry workshop in Toronto.

Introduction

XPath (which stands for XML Path Language) is an expression language used to specify parts of an XML document. XPath is rarely used on its own, rather it is used within software and languages that are aimed at manipulating XML documents, such as XSLT, XQuery or the web scraping tools that will be introduced later in this lesson. XPath can also be used in documents with a structure that is similar to XML, like HTML.

Markup Languages

XML and HTML are markup languages . This means that they use a set of tags or rules to organise and provide information about the data they contain. This structure helps to automate processing, editing, formatting, displaying, printing, etc. that information.

XML documents stores data in plain text format. This provides a software- and hardware-independent way of storing, transporting, and sharing data. XML format is an open format, meant to be software agnostic. You can open an XML document in any text editor and the data it contains will be shown as it is meant to be represented. This allows for exchange between incompatible systems and easier conversion of data.

XML and HTML Note that HTML and XML have a very similar structure, which is why XPath can be used almost interchangeably to navigate both HTML and XML documents. In fact, starting with HTML5, HTML documents are fully-formed XML documents. In a sense, HTML is like a particular dialect of XML.

XML document follows basic syntax rules:

• An XML document is structured using nodes , which include element nodes, attribute nodes and text nodes
• XML element nodes must have an opening and closing tag, e.g. <catfood> opening tag and </catfood> closing tag
• XML tags are case sensitive, e.g. <catfood> does not equal <catFood>
• XML elements must be properly nested:
• Text nodes (data) are contained inside the opening and closing tags
• XML attribute nodes contain values that must be quoted, e.g. <catfood type="basic"></catfood>

XPath Expressions

XPath is written using expressions. Expressions consist of values, e.g., 368, and operators, e.g., +, that will return a single value. 368 + 275 is an example of an expression. It will return the value 643 . In programming terminology, this is called evaluating, which simply means reducing down to a single value. A single value with no operators, e.g. 35 , can also be called an expression, though it will evaluate only to its existing value, e.g. 35.

Using XPath is similar to using advanced search in a library catalogue, where the structured nature of bibliographic information allows us to specify which metadata fields to query. For example, if we want to find books about Shakespeare but not works by him, we can limit our search function to the subject field only.

When we use XPath, we do not need to know in advance what the data we want looks like (as we would with regular expressions, where we need to know the pattern of the data). Since XML documents are structured into fields called nodes, XPath makes use of that structure to navigate through the nodes to select the data we want. We just need to know in which nodes within an XML file the data we want to find resides. When XPath expressions are evaluated on XML documents, they return objects containing the nodes that you specify.

XPath always assumes structured data.

Now let’s start using XPath.

Navigating through the HTML node tree using XPath

A popular way to represent the structure of an XML or HTML document is the node tree :

In an HTML document, everything is a node:

• The entire document is a document node
• Every HTML element is an element node
• The text inside HTML elements are text nodes

The nodes in such a tree have a hierarchical relationship to each other. We use the terms parent , child and sibling to describe these relationships:

• In a node tree, the top node is called the root (or root node )
• Every node has exactly one parent , except the root (which has no parent)
• A node can have zero, one or several children
• Siblings are nodes with the same parent
• The sequence of connections from node to node is called a path

Paths in XPath are defined using slashes ( / ) to separate the steps in a node connection sequence, much like URLs or Unix directories.

In XPath, all expressions are evaluated based on a context node . The context node is the node in which a path starts from. The default context is the root node, indicated by a single slash (/), as in the example above.

The most useful path expressions are listed below:

Navigating through a webpage with XPath using a browser console

We will use the HTML code that describes this very page you are reading as an example. By default, a web browser interprets the HTML code to determine what markup to apply to the various elements of a document, and the code is invisible. To make the underlying code visible, all browsers have a function to display the raw HTML content of a web page.

Display the source of this page Using your favourite browser, display the HTML source code of this page. Tip: in most browsers, all you have to do is do a right-click anywhere on the page and select the “View Page Source” option (“Show Page Source” in Safari). Another tab should open with the raw HTML that makes this page. See if you can locate its various elements, and this challenge box in particular.

Using the Safari browser If you are using Safari, you must first turn on the “Develop” menu in order to view the page source, and use the functions that we will use later in this section. To do so, navigate to Safari > Preferences and in the Advanced tab select the “Show Develop in menu bar” option. Note: In recent versions of Safari you must first turn on the “Develop” menu (in Preferences) and then navigate to Develop > Show Javascript Console and then click on the “Console” tab.

The HTML structure of the page you are currently reading looks something like this (most text and elements have been removed for clarity):

We can see from the source code that the title of this page is in a title element that is itself inside the head element, which is itself inside an html element that contains the entire content of the page.

Say we wanted to tell a web scraper to look for the title of this page, we would use this information to indicate the path the scraper would need to follow at it navigates through the HTML content of the page to reach the title element. XPath allows us to do that.

We can run XPath queries directly from within all major modern browsers, by enabling the built-in JavaScript console.

Display the console in your browser In Firefox, use to the Tools > Web Developer > Web Console menu item. In Chrome, use the View > Developer > JavaScript Console menu item. In Safari, use the Develop > Show Error Console menu item. If your Safari browser doesn’t have a Develop menu, you must first enable this option in the Preferences, see above.

Here is how the console looks like in the Firefox browser:

For now, don’t worry too much about error messages if you see any in the console when you open it. The console should display a prompt with a > character ( >> in Firefox) inviting you to type commands.

The syntax to run an XPath query within the JavaScript console is $x("XPATH_QUERY") , for example:

This should return something similar to

The output can vary slightly based on the browser you are using. For example in Chrome, you have to “open” the return object by clicking on it in order to view its contents.

Let’s look closer at the XPath query used in the example above: /html/head/title/text() . The first / indicates the root of the document. With that query, we told the browser to

Using this syntax, XPath thus allows us to determine the exact path to a node.

Select the “Introduction” title Write an XPath query that selects the “Introduction” title above and try running it in the console. Tip: if a query returns multiple elements, the syntax element[1] can be used. Note that XPath uses one-based indexing, therefore the first element has index 1, the second has index 2 etc. Solution $x("/html/body/div/article/h1[1]") should produce something similar to <- Array [ <h1#introduction> ]

Before we look into other ways to reach a specific HTML node using XPath, let’s start by looking closer at how nodes are arranged within a document and what their relationships with each others are.

For example, to select all the blockquote nodes of this page, we can write

This produces an array of objects:

This selects all the blockquote elements that are under html/body/div . If we want instead to select all blockquote elements in this document, we can use the // syntax instead:

This produces a longer array of objects:

Why is the second array longer? If you look closely into the array that is returned by the $x("//blockquote") query above, you should see that it contains objects like <blockquote.solution> that were not included in the results of the first query. Why is this so? Tip: Look at the source code and see how the challenges and solutions elements are organised.

We can use the class attribute of certain elements to filter down results. For example, looking at the list of blockquote elements returned by the previous query, and by looking at this page’s source, we can see that the blockquote elements on this page are of different classes (challenge, solution, callout, etc.).

To refine the above query to get all the blockquote elements of the challenge class, we can type

which returns

Select the “Introduction” title by ID In a previous challenge, we were able to select the “Introduction” title because we knew it was the first h1 element on the page. But what if we didn’t know how many such elements were on the page. In other words, is there a different attribute that allows us to uniquely identify that title element? Using the path expressions introduced above, rewrite your XPath query to select the “Introduction” title without using the [1] index notation. Tips: Look at the source of the page or use the “Inspect element” function of your browser to see what other information would enable us to uniquely identify that element. The syntax for selecting an element like <div id="mytarget"> is div[@id = 'mytarget'] . Solution $x("/html/body/div/h1[@id='introduction']") should produce something similar to <- Array [ <h1#introduction> ]

Select this challenge box Using an XPath query in the JavaScript console of your browser, select the element that contains the text you are currently reading on this page. Tips: In principle, id attributes in HTML are unique on a page. This means that if you know the id of the element you are looking for, you should be able to construct an XPath that looks for this value without having to worry about where in the node tree the target element is located. The syntax for selecting an element like <div id="mytarget"> is div[@id = 'mytarget'] . Remember that XPath queries are relative to a context node, and by default that node is the root node. Use the // syntax to select for elements regardless of where they are in the tree. The syntax to select the parent element relative to a context node is .. The $x(...) JavaScript syntax will always return an array of nodes, regardless of the number of nodes returned by the query. Contrary to XPath, JavaScript uses zero based indexing , so the syntax to get the first element of that array is therefore $x(...)[0] . Make sure you select this entire challenge box. If the result of your query displays only the title of this box, have a second look at the HTML structure of the document and try to figure out how to “expand” your selection to the entire challenge box. Solution Let’s have a look at the HTML code of this page, around this challenge box (using the “View Source” option) in our browser). The code looks something like this: <!doctype html> <html lang="en"> <head> (...) </head> <body> <div class="container"> (...) <blockquote class="challenge"> <h2 id="select-this-challenge-box">Select this challenge box</h2> <p>Using an XPath query in the JavaScript console of your browser...</p> (...) </blockquote> (...) </div> </body> </html> We know that the id attribute should be unique, so we can use this to select the h2 element inside the challenge box: $x("//h2[@id = 'select-this-challenge-box']/..")[0] This should return something like <- <blockquote class="challenge"> Let’s walk through that syntax: $x(" This function tells the browser we want it to execute an XPath query. // Look anywhere in the document… h2 … for an h2 element … [@id = 'select-this-challenge-box'] … that has an id attribute set to select-this-challenge-box … .. and select the parent node of that h2 element ")" This is the end of the XPath query. [0] Select the first element of the resulting array (since $x() returns an array of nodes and we are only interested in the first one). By hovering on the object returned by your XPath query in the console, your browser should helpfully highlight that object in the document, enabling you to make sure you got the right one:

Advanced XPath syntax

There’s much more to XPath. We won’t cover this material in the workshop, but list it here for additional reading. An XPath cheatsheet is linked at the bottom of this page.

Operators are used to compare nodes. There are mathematical operators, boolean operators. Operators can give you boolean (true/false values) as a result. Here are some useful ones:

Predicates are used to find a specific node or a node that contains a specific value.

Predicates are always embedded in square brackets, and are meant to provide additional filtering information to bring back nodes. You can filter on a node by using operators or functions.

XPath wildcards can be used to select unknown XML nodes.

In-text search

XPath can do in-text searching using functions and also supports regex with its matches() function. Note: in-text searching is case-sensitive!

Complete syntax: XPath Axes

XPath Axes fuller syntax of how to use XPath. Provides all of the different ways to specify the path by describing more fully the relationships between nodes and their connections. The XPath specification describes 13 different axes:

• self ‐‐ the context node itself
• child ‐‐ the children of the context node
• descendant ‐‐ all descendants (children+)
• parent ‐‐ the parent (empty if at the root)
• ancestor ‐‐ all ancestors from the parent to the root
• descendant‐or‐self ‐‐ the union of descendant and self • ancestor‐or‐self ‐‐ the union of ancestor and self
• following‐sibling ‐‐ siblings to the right
• preceding‐sibling ‐‐ siblings to the left
• following ‐‐ all following nodes in the document, excluding descendants
• preceding ‐‐ all preceding nodes in the document, excluding ancestors • attribute ‐‐ the attributes of the context node

Oftentimes, the elements we are looking for on a page have no ID attribute or other uniquely identifying features, so the next best thing is to aim for neighboring elements that we can identify more easily and then use node relationships to get from those easy to identify elements to the target elements.

For example, the node tree image above has no uniquely identifying feature like an ID attribute. However, it is just below the section header “Navigating through the HTML node tree using XPath”. Looking at the source code of the page, we see that that header is a h2 element with the id navigating-through-the-html-node-tree-using-xpath .

• W3Schools: JavaScript HTML DOM Navigation
• XPath Cheatsheet
• Another XPath Cheatsheet

Key Points XML and HTML are markup languages. They provide structure to documents. XML and HTML documents are made out of nodes, which form a hierarchy. The hierarchy of nodes inside a document is called the node tree. Relationships between nodes are: parent, child, sibling. XPath queries are constructed as paths going up or down the node tree. XPath queries can be run in the browser using the $x() function.

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• English (US)

XPath stands for XML Path Language. It uses a non-XML syntax to provide a flexible way of addressing (pointing to) different parts of an XML document. It can also be used to test addressed nodes within a document to determine whether they match a pattern or not.

XPath is mainly used in XSLT , but can also be used as a much more powerful way of navigating through the DOM of any XML-like language document using XPathExpression , such as HTML and SVG , instead of relying on the Document.getElementById() or Document.querySelectorAll() methods, the Node.childNodes properties, and other DOM Core features.

XPath uses a path notation (as in URLs) for navigating through the hierarchical structure of an XML document. It uses a non-XML syntax so that it can be used in URIs and XML attribute values.

Note: Support for XPath varies widely; it's supported reasonably well in Firefox (although there are no plans to improve support further), while other browsers implement it to a lesser extent, if at all. If you need a polyfill, you may consider js-xpath or wicked-good-xpath .

Documentation

Describes a non-XSLT use of XPath.

List and definition of the axes defined in the XPath specification. Axes are used to describe the relationships between nodes.

List and description of the core XPath functions and XSLT-specific additions to XPath.

XSLT uses XPath to address code segments in an XML document that it wishes to transform.

These are JavaScript utility functions, that can be used in your own code, based on DOM Level 3 XPath APIs.

This extensive introduction to XSLT and XPath assumes no prior knowledge of the technologies, and guides the reader through background, context, structure, concepts, and introductory terminology.

An online XPath Builder/Debugger.

Related Topics

• XSLT , XML , DOM
• Comparison of CSS Selectors and XPath

• Getting started with xpath
• Check if a node is present
• Check if a node's text is empty
• Find nodes that have a specific attribute
• Finding elements containing specific attributes
• Finding elements containing specific text
• Get nodes relative to the current node
• Get the count of nodes
• Location paths and axes
• Select nodes based on their children
• Select nodes with names equal to or containing some string

xpath Getting started with xpath Testing Xpaths in browser console

Fastest entity framework extensions.

A quick way to test your xpath is in your browser developer tool console.

$ - specifies it is a selector.

x - specifies it is using xpaths

When this command is entered it will return all occurrences of elements that are buttons with text equal to Submit.

Got any xpath Question?

• Advertise with us
• Cookie Policy
• Privacy Policy

Get monthly updates about new articles, cheatsheets, and tricks.

Pragmatic Test Labs

Mastering xpath for selenium test automation engineers, introduction.

Selenium test automation engineers must be comfortable in locating elements in web pages . XPath and CSS are the most powerfu l location strategies used in Selenium as compared to other location strategies (id, name, className,  linkText, partialLinkText  and tagName )

Mastering XPath and/or CSS is essential for the Selenium test automation engineers to locate dynamic web elements, elements without i ds or names and elements with dynamic ids and names . Tagname is not a useful location strategy to locate elements as there will be  many elements with the same tagname. LinkText is only useful for the anchor   <a> tags only. Also, it is not useful when the visible text changes as in multilingual systems

It is noted that most of the amateur Selenium automation engineers do not pay much attention to master location strategies. Recording and playback will not work with the applications with dynamic elements. This leads to failure of the automated test script s (brittle) when web pages with dynamic contents are automated. Most of the testers rely on extracting the XPaths from browser plugins. These tools have limitations and do not provide the best XPath for dynamic elements.

We will discuss XPath in detail with examples and explore a few tools to generate XPaths easily.

Please refer to our blog post on Mastering CSS for Selenium Test Automation if you wish to switch to CSS.

Terms used in XPath

Lets get familiar with the basic terms used in XPath syntax.

Using XPath for locating elements in HTML

We have our own way of introducing (explaining) XPath to the trainees in our public training programs.

We write following two equations.  A=B and B=C. We ask the students what can be derived from these two expressions. Immediately students reply with the answer  A=C, even before the question is asked :-).

Then we give following two statements

• XPath can be used for locating the elements  in XML 
• XML and HTML have similar syntax (HTML is a subset of  XML)

Hence  we can derive XPath can be used for locating elements in HTML pages (web pages) too  . Selenium uses XPath to locate elements in web pages.

Why do we need to master many XPath syntaxes?

We may not be able to locate some elements using their ID or Name as some elements do not have unique attributes (id or name). Some attributes are dynamically changed. There could be elements without any attribute too. Hence we may have to locate them differently than the static elements.

XPath can be used for

• Locating elements with respect to a known element
• Locating elements with partially static attribute values
• Locating elements without attributes or without unique attributes

XPath can do bidirectional navigation (Going forward and backward)

XPath is one of the most flexible and strongest location strategies.

Types of XPath

We have grouped XPaths into three types.

Absolute XPath

Absolute XPaths starts with the root of the HTML pages. 

Absolute XPaths are not advisable for most of the time due to following reasons

• Absolute XPaths are lengthier and hence they are not readable
• Absolute XPaths are not resilient. They tend to break when minor structural changes are introduced to the web pages

Absolute XPaths shall be used only when a relative XPath cannot be constructed. (highly unlikely). I t is not recommended to use absolute XPath in Selenium.

Syntax: Absolute XPaths start with   /html

Example : /html/body/div[1]/div/div[2]/form/div[2]/input

Relative XPath

Relative XPaths is used for locating  elements with respect to a element with known (solid)  XPath. The element of your choice is referred relative to a known element.

Syntax : Relative XPaths are started with two forward slashes  ‘ //’.

Examples  : //div[@id=’divUsername’] /input //form/div[@id=’divUsername’] /input //form/* /input

There could be zero or more elements between the context element  (starting element with a known Xpath) and the target element 

• Absolute XPaths are faster than the relative XPaths
• Use shortest possible relative XPaths

Exact XPath

Locating elements using their own tag-name, attributes , values and inner text. This is simpler and very useful if the target element has a unique way to locate it. Exact Xpath is resilient to structural changes of the web page. 

What should be considered when choosing an XPath?

It is important to consider following while choosing an XPath from available options.

A good locator is:

• Descriptive
• Shorter in length

When you want to locate a single element your XPath should have only one candidate element ( unique ). It will be easier to identify the element if it is descriptive  and short(for maintainability ). XPaths generated from tools may not be user-friendly .  It should be possible to locate an element with given XPath when the test is run again in subsequent releases too. XPath should be selected in such a way it is valid even after changes in DOM ( resilient ). You will have multiple XPath options. A shorter XPath shall be selected to make it more readable in your test scripts.

Sample HTML code

Locating an elements with a known attribute.

The following syntax can be used for locating elements when at least one of the attribute’s value  is unique and static.

//*[@ attributeName = ’ value ’ ]

Let’s locate the  username field in following.

We have three valid XPaths

• //*[@ i d = ’ txtUsername ’ ]
• //*[@ name = ’ txtUsername ’ ]
• //*[@type=’text’]

NOTE :  Third XPath should not be used even though it is a valid XPath. Because It will not be a unique XPath in most of the cases. There will be many elements with type = ’text’ . Hence Selenium will not be able to locate the target element uniquely. 

Single quotations should be used to enclose the values (in Java).You need to use escape character if you wish to enclose the values with double quotes.

Example : //*[@id=\”txtUsername\”]

In our real life we cannot locate a person with name Mohammed  in a Muslim community.

How does Selenium works when there are multiple elements (candidates) for an XPath?

Selenium will pick the first element in the path if there are multiple candidates for a given XPath when webdriver. findElement ( By.xpath (“ XPATH ”)) method is used. All the candidate elements can be assigned to a List when webdriver.findElements( By.xpath (“ XPATH ”)) method is used.

• To select the third input element :  // form / input [3]
• To select the last input element :  // form / input [last()]

Locating elements by position is discussed further in a separate section.

findElement method throws NoSuchElementException error when there is no elements with given XPath. Use findElement s method and check the size when working with non-present elements. 

Locating Elements with a Tag-name and an Attribute

// tagName [@ attributeName = ’ value ’ ]

Let’s consider locating the username input field again 

Examples :  

• // input [@ id = ’ txtUsername ’ ]
• // input [@ name = ’ txtUsername ’ ]

This is one of the most commonly used Xpath. Most of the plugs can generate above XPaths automatically  

Locating Elements with static Visible Text (exact match)

Following syntax is used for locating elements containing exact text within opening tag and closing tag ( inner text ).

// tagName [ text() = ’exact text’ ] or /*[ text() =’ exact text ’]

Let’s consider locating following hyperlink 

• // a [ text() = ’Pragmatic’ ]
• // * [ text() = ’Pragmatic’ ]

NOTE : The inner text is case sensitive .

Locating elements by the visible text is not advisable

• If you are testing a multilingual application
• When same text is appearing in more than one location.

Locating Elements when part of the visible text is static (partial match)

// tagName [ contains ( text() ,’ substring ’)] // tagName [ contains (.,’ substring ’)] //*[ contains ( text() ,’ substring ’)]

• // a [ contains ( text() ,’ Pragmatic’ )]
• // a [ contains (., ‘ Test Labs ‘)]
• //*[ contains ( text() , ‘ Test Labs ‘)]

Validate the XPath syntax before running the test scripts. Validating the XPath is discussed in a separate section .

Locating Elements when prefix of the inner text is static

You can locate the elements when part of the starting text of the inner text are static.

// tagName [ starts-with ( text() ,’ Prefix of Inner Text ’)] //*[ starts-with ( text() ,’ Prefix of Inner Text ’ ’)]

• // a [ starts-with ( text() ,’ Pragmatic’ )]
• //*[ starts-with ( text() , ‘ Prag ‘)]

Locating elements with Visible text in input elements

Locating input elements with visible text should not be confused with the locating elements with inner text as in above sections. Attribute value should be used for locating the visible text in input type elements.

//tagName [@ value = ’ visibleText ’ ]

• //input [@ value = ’ Janesh ’ ]

We have already discuss the process of locating elements by tag-name and an attribute.

Locating Elements with Multiple Attributes

Sometimes it may not be possible to locate an element with a single attribute uniquely as there could be more than one candidate elements with given attribute. In the real world, we have a similar scenarios. We cannot locate a person by just their first name or last name alone. We will have to use a combination of first name and last name to locate a person uniquely without making any confusion.

Similar technique is used in Selenium for locating elements when there are more than one elements with a given attribute . We will use two or more attributes together to locate an element uniquely. 

Syntax : 

//*[ attribute1 = ’ value1 ’ ][ attribute2 = ’ value2 ’ ]…[ attributeN = ’ valueN ’ ] or // tagName [ attribute1 = ’ value1 ’ ] [ attribute2 = ’ value2 ’ ]…[ attributeN = ’ valueN ’ ] or  //*[ attribute1 = ’ value1 ’ and  attribute2 = ’ value2 ] // tagName [ attribute1 = ’ value1 ’ and  attribute2 = ’ value2 ]

• //* [@ type = ’ submit ’ ][@ value = ’ LOGIN ’ ]
• // input [@ class = ’ button ’ ][@ type = ’ submit ’ ][@ value = ’ LOGIN ’ ][@ name = ’ Submit ’
• //* [@ type = ’ submit ’ and  @ value = ’ LOGIN ’ ]

Locating Elements with Dynamic Attribute values

Following syntax could be used when a part of the attribute’s values are NOT changed. We can use the non changing value for locating the element.

// elementName [ contains (@ attributeName , ’ substring of the value ’)] or //*[ contains (@ attributeName , ’ substring of the value ’)] // elementName [ starts-with (@ attributeName , ’ fixed prefix of the value ’)]

• // a [ contains (@ href , ’ pragmatic ’ )]
• //*[ contains (@ href , ’ testlabs ’ )]
• // a [ starts-with (@ href , ’ pragmatic ’ )]

The ends-with() function is part of XPath 2.0. Most of the browsers do not support Xpath 2.0 at the time of the writing. 

Locating elements relative to known element

If our target element s do not have unique attribute(s) or static innerHTML, we need to locate the elements with respective to an element who has an unchanging XPath .

We do this very well in our real life. We always give direction to an unknown  location with respective to a well known location (a landmark ). Giving direction to your home from a well-known shop, statue, railway station etc.

XPath has thirteen ( 13 ) different axes. We will look into a subset of useful axes in this blog post which can be used with Selenium.

Your target element should be closer to the known element ( context  element ) to make XPath shorter, resilient  and readable. 

Source : XPath Expression components. http://www.iro.umontreal.ca/~lapalme/ForestInsteadOfTheTrees/HTML/ch04s01.html

Locating a parent element.

The parent axis contains the parent of the context node. Every context element has only one parent element except root element (html). 

//< knownXpath > / parent :: * or //< knownXpath > / parent :: elementName //< knownXpath > /..

Let’s see how to locate the  form element with respect to the username field. We need to select an element with unchanging XPath. In this case we will take the username field.

XPath of the known element : //input[@id=’txtUsername’]

• //input[@id=’txtUsername’] /parent:: form
• //input[@id=’txtUsername’] /parent::*
• //input[@id=’txtUsername’] /..

There can be only one parent to a context (known) element. Hence specifying the element name is optional. But it is good to specify the element name for readability.

Locating a child element

The child axis contains the children of the context node

//<xpathOfContextElement> / child:: <elementName>  or //<xpathOfContextElement> / child:: * //<xpathOfContextElement> / <elementName>

In following examples context element’s XPath is div[@id=’divUsername’]

• //div[@id=’divUsername’]/ child :: input
• //div[@id=’divUsername’] / input

In practice / is used  instead of child:: from the known XPath.

Locating grand children 

Syntax :  

// <xpathOfContextElement> / */ < elementName >   // <xpathOfContextElement> /child / < elementName >  

• //form /*/ input
• //form /div/ input

Locating ancestors of a known element

The ancestor axis contains the ancestors of the known element; ancestor axis consists of the parent of a known element and the parent’s parent so on.

// <xpathOfContextElement> / ancestor :: < elementName > or   // <xpathOfContextElement> / ancestor :: *

• //input[@id=’txtUsername’]/ ancestor :: form    : will select the form element
• //input[@id=’txtUsername’]/ ancestor :: *         : div element will be selected from the available candidates (div, form etc) as it comes first in the path if you use findElement method.  

Locating descendants of a known element

The descendant axis contains the descendants of a known element; descendant axis consists of the children of a context element and their children and so on.

// <xpathOfContextElement> / descendant:: < elementName > or   // <xpathOfContextElement> / descendant:: *

• //form[@id=’frmLogin’]/ descendant:: input
• //form[@id=’frmLogin’] / / input

You can use // instead of descendant:: keyword to locate descendants. 

Locating following elements

Keyword following:: can be used for locating  element(s) anywhere below the tree with respect to a known element (context element).

// < xpathOfContextElement > / following :: < elementName > or // < xpathOfConextElement > / following :: *

• //input[@id=’txtUsername’] / following :: input
• //input[@id=’txtUsername’] / following :: *

There are two candidate elements. Any descendant elements after the first candidate in the path are excluded by Selenium when you use findElement method.

To select the login button input element with respect to the username field.

• //input[@id=’txtUsername’] / following :: input[last()]  
• //input[@id=’txtUsername’] / following :: input[2]  

Locating preceding element  

Keyword preceding:: is used for locating an element before a known (XPath) element.

The preceding axis contains all nodes that are descendants of the root of the tree in which the context node is found, are not ancestors of the context node, and occur before the context node in document order

//<xpathOfContextElement> / preceding:: < elementName > or //<xpathOfContextElement> / preceding:: *

• //span[text()=’Password’] / preceding :: input

There will be two candidate elements (username and password elements). Selenium will select the password input element when findElement method is used.  Elements are ordered from the context element ( span ).

     2.   //span[text()=’Password’] / preceding :: input[2]

Above can be used for selecting the username field.

Locating following sibling

Keyword following-sibling:: is used to locate the element( s ) comes after a context element within same HTML hierarchy. Following siblings are the elements (children) of the context node’s parent that occur after the context element in document order

//<xpathOfContextElement> / following-sibling:: < elementName > or //<xpathOfContextElement> / following-sibling:: *

• //*[@id=’txtUsername’] / following-sibling:: span
• //*[@id=’txtUsername’] / following-sibling:: *

Locating preceding sibling

Keyword preceding-sibling:: is used to selects the sibling( s ) that comes before the context node with a known XPath, those elements (children) of the context node’s parent that occur before the context element in document order.

//<xpathOfKnownElement> / preceding-sibling:: < elementName > or //<xpathOfKnownElement> / preceding-sibling:: *

• //span[contains(text(),’Username’)] / preceding-sibling:: input
• //span[contains(text(),’Username’)] / preceding-sibling:: *

With this we complete discussion of XPath with axes. Please note that we have not discussed attribute, ancestor-or-self, descendant-or-self, namespace and self axes in this article as they do not have practical usage in the context of Selenium.

Locating Several XPaths

You can locate multiple elements by separating two or more  XPath expressions with | character.  

XPath1| Xpath2…. |XPathN

If the first XPath is available in the first element is selected by Selenium for further actions. If both are available first one is Selected when you use findElement method. Both will be selected if you use findElements method. If only second XPath ( Xpath2 ) is available then second element will be selected. If both of them are NOT available Selenium gives an error, NoSuchElementException when you use findElement method. 

• // input [@ id = ’ txtUsername ’ ]|// input [@ name = ’ txtPassword ’ ] In this example available elements can be located. This is useful when you know one of them would exist when the page is loaded.
• // * [@ id = ’ txtUsername ’ ]|// * [@ name = ’ txtPassword ’ ]| * [@ name = ’ btnLogin ’ ]

Working with Operators 

You can use various operators to compare numeric value in attributes and inner text.  We have addition ( + ), subtraction ( – ), multiplication ( * ), division ( div ), equal ( = ), not equal ( != ), less than ( < ), less than or equal ( <= ), greater than ( > ), greater than or equal ( >= ), and ,  or , mod operators.

Lets see an example 

Say you need to locate element(s) with deal price greater than 100

//span[ contains( @class,’dealPriceText’ ) and text() > 100]

You can combine the techniques learned to build complex XPaths and locate any element in DOM. 

Locating an element by position

Locating element by position can be used for locating an element explicitly when there are many candidate elements matching the given XPath.

Xpath [ n ]  or Xpath [ position()=n ] Xpath [ position() > n ]  position() can be combined with operators   Xpath [ last() ] Xpath [ last()-n ]

XPath  //a[text()=’0001′]/../following-sibling::td has five candidate elements. Order selectors can be used for filtering the target element(s).

• //a[text()=’0001′]/../following-sibling::td [ 1 ] or //a[text()=’0001′]/../following-sibling::td [ position()=1 ]
• //a[text()=’0001′]/../following-sibling::td [ last()-3 ]
• //a[text()=’0001′]/../following-sibling::td [ last() ]

Validating  XPath

It is important to ensure XPath used in your automation script is validated before running the script. Fixing the XPaths after running the test is expensive. There are many tools available to validate the correctness of the XPaths.

Tools for extracting XPaths

You can search for the extensions available in browsers (chrome, firefox) to extract the XPaths. Most of them can generate the XPath of simple elements and fail to give better XPaths for dynamic and complex elements. Most of them are longer, not user-friendly and brittle. Hence it is advisable to be comfortable in syntax of writing XPaths from scratch and validating them using a tool before using them in your tests.

Please refer to the plugins’ documentation to get most from them. Here are few extensions you can use.

• Ranorex Selocity by Ranorex [Rich feature set with user friendly interfaces]
• ChroPath by Autonomiq.io [Frequently updated]
• Chrome DevTools window

There are many browser plugins available for validating and extracting XPaths. My personal favorite is Ranorex Selocity for extracting XPath and validating the XPath syntax.

• Install Ranorex Selocity plugin from Chrome store
• Navigate to your web page
• Select the target element
• Inspect the element
• Select Ranorex Selocity in developer tool
• XPath of the selected element is automatically generated

Copy XPath from Context Menu 

To Verify a Xpath 

• Type the XPath syntax in enter selector input box
• Hit enter to verify the syntax

Following demonstrates using Ranorex Selocity for validating a XPath syntax.

XPath or CSS

CSS and XPath are the most popular, widely used and powerful location strategies within the Selenium test automation community. CSS has gained wider acceptance from the test automation engineers due to following reasons. (People in favor of CSS says)

• CSS more readable ( simpler )
• CSS is faster (especially in IE)

Those who are in favor of XPath says about its ability to transverse around the page in any direction where CSS cannot. XPath can traverse up and down the DOM. CSS can traverse only down the DOM. These claims may be already outdated :-).

Some research demonstrates that there is no significant difference in speed. Mastering both of them is a good idea for the Selenium test automation engineers who wish to build their career around Selenium. It is better to a use single location strategy for a project for a number of reasons.

Some gurus advice a hybrid approach. They use ID  and name first if they are static and moving to CSS. XPath is used only when it is required.

CSS is used internally in By.id locator. CSS is the default locator in Selenium.

Following is from the API documentation.

Care should be taken when using an XPath selector with a webdriver.WebElement as WebDriver will respect the context in the specified in the selector. For example, given the selector //div , WebDriver will search from the document root regardless of whether the locator was used with a WebElement.

Convert your XPath to CSS

If you have decided use CSS and want to convert existing XPaths into CSS following program can be used. ccsify by Santiago Suarez Ordoñez

You can practice XPath using   XPath selector game

It’s a fun game to learn and practice XPath.

Quick Reference

Terminology, root element.

The top most element in a document tree. It is html element in web pages.

Elements that have the same parent as the context node

Following 

All elements that appear after the context node except any descendant

Preceding 

All elements that appear before the context node except any ancestors

Following Siblings 

Nodes that have the same parent and appear after the context node .

Preceding Siblings 

Nodes that have the same parent and appear before the context node.

Node’s parent, parent’s parent and so on.

Descendants

Node’s children, children’s children and so on

Text between the opening tag and closing tag of an element.

Document Object Model. It defines the logical structure of HTML documents and the way HTML is accessed and manipulated.  

Automationtricks.blogspot.com. . How to use functions in xpath in selenium . [online] Available at: http://automationtricks.blogspot.com/2010/09/how-to-use-functions-in-xpath-in.html [Accessed 30 Jan 2020].

Online Tools  for  Developers. (2020). Online  XPath Tester . [online] Available at: https://extendsclass.com/xpath-tester.html [Accessed 08 Jan 2020].

Seleniumhq.github.io. (2020). Selenium API documentation  [online] Available at: https://selenium.dev/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_By.html [Accessed 05 Feb 2020].

Onion.net . W3C XPath Exercises . [online] Available at: http://learn.onion.net/language=en/35426/w3c-xpath [Accessed 08 Feb2020].

W3schools.com. (2020). XPath Nodes . [online] Available at: https://www.w3schools.com/xml/xpath_nodes.asp [Accessed 30 Jan 2020].

W3schools.com. (2020). XPath Operators . [online] Available at: https://www.w3schools.com/xml/xpath_operators.asp [Accessed 08 Jan 2020].

W3schools.com. (2018). XPath Syntax . [online] Available at: https://www.w3schools.com/xml/xpath_syntax.asp [Accessed 30 Jan 2020].

  Xpath selectors – the Game! . [online] Available at: https://topswagcode.com/xpath/ [Accessed 30 Jan 2020].

Zvon.org. (2018). XPath Tutorials . [online] Available at: http://zvon.org/xxl/XPathTutorial/General/examples.html [Accessed 30 Jan 2020].

Author: Janesh Kodikara

Performance Tester | JMeter Trainer | Software Testing Service Provider

XML Tutorial

Xpath tutorial, xslt tutorial, xquery tutorial, xsd data types, web services, xpath examples.

Let's try to learn some basic XPath syntax by looking at some examples.

The XML Example Document

We will use the following XML document in the examples below.

"books.xml":

View the "books.xml" file in your browser .

Advertisement

Loading the XML Document

Using an XMLHttpRequest object to load XML documents is supported in all modern browsers.

Selecting Nodes

Unfortunately, there are different ways of dealing with XPath in different browsers.

Chrome, Firefox, Edge, Opera, and Safari use the evaluate() method to select nodes:

Internet Explorer uses the selectNodes() method to select node:

In our examples we have included code that should work with most major browsers.

Select all the titles

The following example selects all the title nodes:

Select the title of the first book

The following example selects the title of the first book node under the bookstore element:

Select all the prices

The following example selects the text from all the price nodes:

Select price nodes with price>35

The following example selects all the price nodes with a price higher than 35:

Select title nodes with price>35

The following example selects all the title nodes with a price higher than 35:

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.

• Today's news
• Reviews and deals
• Climate change
• 2024 election
• Fall allergies
• Health news
• Mental health
• Sexual health
• Family health
• So mini ways
• Unapologetically
• Buying guides

Entertainment

• How to Watch
• My watchlist
• Stock market
• Biden economy
• Personal finance
• Stocks: most active
• Stocks: gainers
• Stocks: losers
• Trending tickers
• World indices
• US Treasury bonds
• Top mutual funds
• Highest open interest
• Highest implied volatility
• Currency converter
• Basic materials
• Communication services
• Consumer cyclical
• Consumer defensive
• Financial services
• Industrials
• Real estate
• Mutual funds
• Credit cards
• Credit card rates
• Balance transfer credit cards
• Business credit cards
• Cash back credit cards
• Rewards credit cards
• Travel credit cards
• Checking accounts
• Online checking accounts
• High-yield savings accounts
• Money market accounts
• Personal loans
• Student loans
• Car insurance
• Home buying
• Options pit
• Investment ideas
• Research reports
• Fantasy football
• Pro Pick 'Em
• College Pick 'Em
• Fantasy baseball
• Fantasy hockey
• Fantasy basketball
• Download the app
• Daily fantasy
• Scores and schedules
• GameChannel
• World Baseball Classic
• Premier League
• CONCACAF League
• Champions League
• Motorsports
• Horse racing
• Newsletters

New on Yahoo

• Privacy Dashboard

15 men brought to military enlistment office after mass brawl in Moscow Oblast

Local security forces brought 15 men to a military enlistment office after a mass brawl at a warehouse of the Russian Wildberries company in Elektrostal, Moscow Oblast on Feb. 8, Russian Telegram channel Shot reported .

29 people were also taken to police stations. Among the arrested were citizens of Kyrgyzstan.

A mass brawl involving over 100 employees and security personnel broke out at the Wildberries warehouse in Elektrostal on Dec. 8.

Read also: Moscow recruits ‘construction brigades’ from Russian students, Ukraine says

We’re bringing the voice of Ukraine to the world. Support us with a one-time donation, or become a Patron !

Read the original article on The New Voice of Ukraine

Recommended Stories

Trump media stock tanks as new filing reveals heavy losses, 'greater risks' on trump's involvement.

After a strong debut last week, shares of Donald Trump's media company were under pressure Monday after meager sales and deep losses were revealed in a new filing with the SEC.

Vontae Davis, former NFL star, found dead in Miami home at age 35

Davis published a children's book about his life in 2019

LSU's Angel Reese opens up about dealing with hateful speech, death threats: 'I've been through so much'

The LSU star said she's dealt with a lot ever since her star run in last year's national championship.

Mock Draft Monday with Field Yates: You will be shocked how early Bo Nix goes

'Mock Draft Monday' rolls on ESPN's Field Yates joining Matt Harmon to break down his latest mock draft. Harmon has Yates break down his mock draft methodology and what goes into his decision making when placing certain prospects on certain teams.

Brock Purdy nearly doubles his salary due to a bonus from NFL's performance-based pay

Brock Purdy and other young NFL players had a nice payday.

Duke's Cooper Flagg, Rutgers' Ace Bailey lead 8 players who impressed during McDonald's All American practices

Ahead of Tuesday night's McDonald's All American Game, Yahoo Sports breaks down eight players who have already made lasting impressions on NBA scouts.

NFL mock draft: Trades galore as one of the best QB prospects slides outside the top 10

Charles McDonald and Nate Tice's latest mock draft has five quarterbacks off the board in the top 13, a big-time weapon for Aaron Rodgers and some steals in the second half of the first round.

Giants fans not happy after team removes tiles dedicated to family members outside Oracle Park

"It made me feel like they desecrated my mom’s and dad’s headstone on their grave."

One fateful decision summed up North Carolina's Sweet 16 demise

Jae’Lyn Withers shot UNC's most important 3-pointer of the game when he had no business firing away. And now the No. 1 Tar Heels are going home.

The 'extreme' Social Security move that actually makes sense

The election year battle over cherished retirement programs is a microcosm explaining why Washington doesn't solve solvable problems.

Through 6 games, Dodgers hitters are showing exactly what they’re capable of: '1 through 9, it's gonna be a tough out'

Yes, the Dodgers have three MVPs atop their lineup, but it's the depth of their offense that will give opposing pitchers nightmares.

Biggest 2024 NFL Draft need for every AFC team | Zero Blitz

Frank Schwab returns to the pod to join Jason Fitz as the duo go back and forth on the biggest NFL news from the weekend. Fitz and Frank discuss the news surrounding Rashee Rice and his suspected involvement in a car wreck in Dallas, Jadeveon Clowney to the Carolina Panthers and the New York Jets trading for Haason Reddick. After the news, Fitz and Frank dive into the biggest need for every AFC team, as they discuss which positions teams need to target in the 2024 NFL Draft. The duo get especially in-depth on the Los Angeles Chargers, New York Jets, Cleveland Browns, New England Patriots and Denver Broncos as they attempt to determine each team's blueprint for success.

Kenny Brooks leaves Virginia Tech for Kentucky job in stunning end of era

Within a couple of weeks, Virginia Tech's Final Four hopes dropped because of Elizabeth Kitley's injury and Brooks exited for the SEC.

USWNT's Korbin Albert apologizes after Megan Rapinoe calls out anti-LGBTQ social media content

Albert took over Rapinoe's No. 15 jersey number this year.

Oakland to reportedly offer A's 5-year lease extension to cover time before Vegas move

Oakland may be the A's home for a little longer.

Ex-Jaguars employee who once hacked team's Jumbotron sentenced to 220 years in prison for child molestation

The FBI searched Samuel Arthur Thompson's home after figuring out he hacked the Jaguars' jumbotron. What they found next was awful.

Trump legal news brief: Judge Merchan expands gag order after Trump goes after his daughter

Following several attacks on his daughter by former President Donald Trump, Judge Juan Merchan expands his gag order in the hush mush money trial to include family members.

Housing's outsized role in the Fed's inflation problem: Morning Brief

Housing prices have been driving a gap between two key inflation readings.

Yankees post about Nestor Cortes hitting a betting prop, and the reaction wasn't positive

Is it OK for teams like the Yankees to post about sports betting?

New Angels manager Ron Washington calls team meeting after just 2 games: ‘We can’t get off track’

Though the meeting came with 160 games still left on the schedule, the Angels were outscored 24-7 in their first two blowout losses of the season.

• Elektrostal, Moscow Oblast /

The attentive barista welcomes guests all year round.

Similar restaurants nearby

Tasty dishes in elektrostal.

Restaurant features in Elektrostal