How do you click on an element with text in Puppeteer?

You may use a XPath selector with page.$x(expression):

const linkHandlers = await page.$x("//a[contains(text(), 'Some text')]");

if (linkHandlers.length > 0) {
  await linkHandlers[0].click();
} else {
  throw new Error("Link not found");
}

Check out clickByText in this gist for a complete example. It takes care of escaping quotes, which is a bit tricky with XPath expressions.

You can also use page.evaluate() to click elements obtained from document.querySelectorAll() that have been filtered by text content:

await page.evaluate(() => {
  [...document.querySelectorAll('.elements button')].find(element => element.textContent === 'Button text').click();
});

Alternatively, you can use page.evaluate() to click an element based on its text content using document.evaluate() and a corresponding XPath expression:

await page.evaluate(() => {
  const xpath = '//*[@class="elements"]//button[contains(text(), "Button text")]';
  const result = document.evaluate(xpath, document, null, XPathResult.ANY_TYPE, null);

  result.iterateNext().click();
});

made quick solution to be able to use advanced css selectors like ":contains(text)"

so using this library you can just

const select = require ('puppeteer-select');

const element = await select(page).getElement('button:contains(Button text)');
await element.click()

Puppeteer 21.0.0 added locator filters which allow for text filtering, optionally alongside p-selectors:

await page
  .locator(".elements button")
  .filter(button =>
    button.textContent.trim().toLowerCase() === "button text"
  )
  .click();

Puppeteer 19.7.1 added "p" (pseudo) selectors, so text/ is deprecated in favor of ::-p-text, which selects on a substring. For example:

const el = await page.waitForSelector("::-p-text(Button text)");

Pseudoselectors can work in conjunction with CSS selectors, like

const el = await page.$(".elements button::-p-text(Button text)");

::-p-aria can also select on text content if it's part of the accessible name:

await page
  .locator('::-p-aria([name="Button text"][role="button"])')
  .click();

In Puppeteer >= 18.0.0, selectors have a text/ prefix that selects on a substring of element text:

const el = await page.waitForSelector("text/Button text");

With regards to XPath specifically, most relevant to pre-18.0.0 Puppeteer:

Since OP's use case appears to be an exact match on the target string "Button text", <button>Button text</button>, text() seems like the correct method rather than the less-precise contains().

Although Thomas makes a good argument for contains when there are sub-elements, avoiding false negatives, using text() avoids a false positive when the button is, say, <button>Button text and more stuff</button>, which seems just as likely a scenario. It's useful to have both tools on hand so you can pick the more appropriate one on a case-by-case basis.

const xp = '//*[@class="elements"]//button[text()="Button text"]';
const [el] = await page.$x(xp);
await el?.click();

Note that many other answers missed the .elements parent class requirement.

Another XPath function is [normalize-space()="Button text"] which "strips leading and trailing white-space from a string, replaces sequences of whitespace characters by a single space" and may be useful for certain cases.

Also, it's often handy to use waitForXPath (removed in v22) which waits for, then returns, the element matching the XPath or throws if it's not found within the specified timeout:

const xp = '//*[@class="elements"]//button[text()="Button text"]';
const el = await page.waitForXPath(xp);
await el.click();

Another flexible approach that works in all environments is to use browser JS to .find() or .filter() out the element(s) you want by text:

// untrusted click (ignores visibility, sometimes useful):
await page.$$eval(".elements *", els =>
  els
    .find(el => el.textContent.trim().toLowerCase() === "button text")
    .click()
);

// trusted click:
const el = await page.evaluateHandle(() =>
  [...document.querySelectorAll(".elements *")]
    .find(el => el.textContent.trim().toLowerCase() === "button text")
);
await el.click();

or:

// untrusted clicks
const els = await page.$$eval(".elements *", els =>
  els
    .filter(el => el.textContent.trim().toLowerCase() === "button text")
    .forEach(el => el.click())
);

// trusted clicks (not ideal)
const els = await page.evaluateHandle(`
  [...document.querySelectorAll(".elements *")]
    .filter(el => el.textContent.trim().toLowerCase() === "button text")
`);
const length = await els.evaluate(els => els.length);

for (let i = 0; i < length; i++) {
  const el = await els.evaluateHandle((els, i) => els[i], i);
  await el.click();
}

If you need to wait for this text, you can use waitForFunction:

const el = await page.waitForFunction(`
  [...document.querySelectorAll(".elements *")]
    .find(el => el.textContent.trim().toLowerCase() === "button text")
`);
await el.click();

Note that the above querySelectorAll strategy will include parent nodes, so <div><div>x</div></div> will find the outer <div> rather than the innermost one. To find the element with the text node immediately containing the text, you can use:

[...document.querySelectorAll("*")].find(el =>
  [...el.childNodes].find(
    el =>
      el.nodeType === Node.TEXT_NODE &&
      el.textContent.trim() === "button text"
  )
);

If you're manipulating a page that happens to have jQuery (or if you import it yourself), you can use the :contains sizzle pseudoselector syntax:

const el = await page.evaluateHandle(`
  $('.elements :contains("Button text")').first()
`);

The solution is

(await page.$$eval(selector, a => a
            .filter(a => a.textContent === 'target text')
))[0].click()

Here is my solution:

let selector = 'a';
    await page.$$eval(selector, anchors => {
        anchors.map(anchor => {
            if(anchor.textContent == 'target text') {
                anchor.click();
                return
            }
        })
    });

There is no supported css selector syntax for text selector or a combinator option, my work around for this would be:

await page.$$eval('selector', selectorMatched => {
    for(i in selectorMatched)
      if(selectorMatched[i].textContent === 'text string'){
          selectorMatched[i].click();
          break;//Remove this line (break statement) if you want to click on all matched elements otherwise the first element only is clicked  
        }
    });

With puppeteer 12.0.1, the following works for me:

await page.click("input[value='Opt1']"); //where value is an attribute of the element input
await page.waitForTimeout(1000);

await page.click("li[value='Nested choice 1']"); //where value is an attribute of the element li after clicking the previous option
await page.waitForTimeout(5000);