diff --git a/src/main/java/net/starlark/java/eval/Eval.java b/src/main/java/net/starlark/java/eval/Eval.java
index b1b050e..3fb5b68 100644
--- a/src/main/java/net/starlark/java/eval/Eval.java
+++ b/src/main/java/net/starlark/java/eval/Eval.java
@@ -562,6 +562,9 @@
         return evalCall(fr, (CallExpression) expr);
       case CAST:
         return eval(fr, ((CastExpression) expr).getValue());
+      case ISINSTANCE:
+        fr.setErrorLocation(expr.getStartLocation());
+        throw new EvalException("isinstance() is not yet supported");
       case IDENTIFIER:
         return evalIdentifier(fr, (Identifier) expr);
       case INDEX:
diff --git a/src/main/java/net/starlark/java/syntax/BUILD b/src/main/java/net/starlark/java/syntax/BUILD
index 65922e6..f192cfc 100644
--- a/src/main/java/net/starlark/java/syntax/BUILD
+++ b/src/main/java/net/starlark/java/syntax/BUILD
@@ -41,6 +41,7 @@
         "IfStatement.java",
         "IndexExpression.java",
         "IntLiteral.java",
+        "IsInstanceExpression.java",
         "LambdaExpression.java",
         "Lexer.java",
         "ListExpression.java",
diff --git a/src/main/java/net/starlark/java/syntax/Expression.java b/src/main/java/net/starlark/java/syntax/Expression.java
index 100a930..92f6c8f 100644
--- a/src/main/java/net/starlark/java/syntax/Expression.java
+++ b/src/main/java/net/starlark/java/syntax/Expression.java
@@ -41,6 +41,7 @@
     IDENTIFIER,
     INDEX,
     INT_LITERAL,
+    ISINSTANCE,
     LAMBDA,
     LIST_EXPR,
     SLICE,
diff --git a/src/main/java/net/starlark/java/syntax/IsInstanceExpression.java b/src/main/java/net/starlark/java/syntax/IsInstanceExpression.java
new file mode 100644
index 0000000..469f889
--- /dev/null
+++ b/src/main/java/net/starlark/java/syntax/IsInstanceExpression.java
@@ -0,0 +1,66 @@
+// Copyright 2025 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package net.starlark.java.syntax;
+
+/** Syntax node for isinstance() expressions. */
+public final class IsInstanceExpression extends Expression {
+  private final int startOffset;
+  private final Expression value;
+  private final Expression type;
+  private final int rparenOffset;
+
+  IsInstanceExpression(
+      FileLocations locs, int startOffset, Expression value, Expression type, int rparenOffset) {
+    super(locs, Kind.ISINSTANCE);
+    this.startOffset = startOffset;
+    this.value = value;
+    this.type = type;
+    this.rparenOffset = rparenOffset;
+  }
+
+  @Override
+  public int getStartOffset() {
+    return startOffset;
+  }
+
+  @Override
+  public int getEndOffset() {
+    return rparenOffset + 1;
+  }
+
+  public Expression getValue() {
+    return value;
+  }
+
+  public Expression getType() {
+    return type;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder buf = new StringBuilder();
+    buf.append("isinstance(");
+    buf.append(value);
+    buf.append(", ");
+    buf.append(type);
+    buf.append(')');
+    return buf.toString();
+  }
+
+  @Override
+  public void accept(NodeVisitor visitor) {
+    visitor.visit(this);
+  }
+}
diff --git a/src/main/java/net/starlark/java/syntax/Lexer.java b/src/main/java/net/starlark/java/syntax/Lexer.java
index 366ed6e..f14e301 100644
--- a/src/main/java/net/starlark/java/syntax/Lexer.java
+++ b/src/main/java/net/starlark/java/syntax/Lexer.java
@@ -562,6 +562,9 @@
 
   private static final Map<String, TokenKind> keywordMap = new HashMap<>();
 
+  /** Additional keywords that are only recognized if --experimental_starlark_type_syntax is set. */
+  private static final Map<String, TokenKind> typeSyntaxExtraKeywordMap = new HashMap<>();
+
   static {
     keywordMap.put("and", TokenKind.AND);
     keywordMap.put("as", TokenKind.AS);
@@ -594,6 +597,9 @@
     keywordMap.put("while", TokenKind.WHILE);
     keywordMap.put("with", TokenKind.WITH);
     keywordMap.put("yield", TokenKind.YIELD);
+
+    typeSyntaxExtraKeywordMap.put("cast", TokenKind.CAST);
+    typeSyntaxExtraKeywordMap.put("isinstance", TokenKind.ISINSTANCE);
   }
 
   /**
@@ -606,16 +612,14 @@
     int oldPos = pos - 1;
     String id = identInterner.intern(scanIdentifier());
     TokenKind kind = keywordMap.get(id);
+    if (kind == null && options.allowTypeSyntax()) {
+      kind = typeSyntaxExtraKeywordMap.get(id);
+    }
     if (kind == null) {
-      if (options.allowTypeSyntax() && id.equals("cast")) {
-        // `cast` is treated as a keyword iff --experimental_starlark_type_syntax is enabled.
-        setToken(TokenKind.CAST, oldPos, pos);
-      } else {
-        setToken(TokenKind.IDENTIFIER, oldPos, pos);
-        // setValue allocates a new String for the raw text, but it's not retained so we don't
-        // bother interning it.
-        setValue(id);
-      }
+      setToken(TokenKind.IDENTIFIER, oldPos, pos);
+      // setValue allocates a new String for the raw text, but it's not retained so we don't
+      // bother interning it.
+      setValue(id);
     } else {
       setToken(kind, oldPos, pos);
     }
diff --git a/src/main/java/net/starlark/java/syntax/NodePrinter.java b/src/main/java/net/starlark/java/syntax/NodePrinter.java
index 044506c..d22e76c 100644
--- a/src/main/java/net/starlark/java/syntax/NodePrinter.java
+++ b/src/main/java/net/starlark/java/syntax/NodePrinter.java
@@ -405,9 +405,9 @@
         {
           CastExpression cast = (CastExpression) expr;
           buf.append("cast(");
-          printExpr(cast.getType());
+          printExpr(cast.getType(), /* canSkipParenthesis= */ true);
           buf.append(", ");
-          printExpr(cast.getValue());
+          printExpr(cast.getValue(), /* canSkipParenthesis= */ true);
           buf.append(')');
           break;
         }
@@ -438,6 +438,17 @@
           break;
         }
 
+      case ISINSTANCE:
+        {
+          IsInstanceExpression isinstance = (IsInstanceExpression) expr;
+          buf.append("isinstance(");
+          printExpr(isinstance.getValue(), /* canSkipParenthesis= */ true);
+          buf.append(", ");
+          printExpr(isinstance.getType(), /* canSkipParenthesis= */ true);
+          buf.append(')');
+          break;
+        }
+
       case FLOAT_LITERAL:
         {
           buf.append(((FloatLiteral) expr).getValue());
diff --git a/src/main/java/net/starlark/java/syntax/NodeVisitor.java b/src/main/java/net/starlark/java/syntax/NodeVisitor.java
index 424c487..d399842 100644
--- a/src/main/java/net/starlark/java/syntax/NodeVisitor.java
+++ b/src/main/java/net/starlark/java/syntax/NodeVisitor.java
@@ -58,6 +58,10 @@
     visit(node.getValue());
   }
 
+  public void visit(IsInstanceExpression node) {
+    visit(node.getValue());
+  }
+
   public void visit(Ellipsis node) {}
 
   public void visit(Identifier node) {}
diff --git a/src/main/java/net/starlark/java/syntax/Parser.java b/src/main/java/net/starlark/java/syntax/Parser.java
index 69b38c4..a2a9862 100644
--- a/src/main/java/net/starlark/java/syntax/Parser.java
+++ b/src/main/java/net/starlark/java/syntax/Parser.java
@@ -569,6 +569,21 @@
     return new CastExpression(locs, startOffset, typeExpr, valueExpr, rparenOffset);
   }
 
+  // isinstance_expression = 'isinstance' '(' expr ',' TypeExpr [','] ')'
+  private Expression parseIsInstanceExpression() {
+    checkAllowTypeSyntax(token.start, token.kind, token.value);
+    int startOffset = expect(TokenKind.ISINSTANCE);
+    expect(TokenKind.LPAREN);
+    Expression valueExpr = parseTest();
+    expect(TokenKind.COMMA);
+    Expression typeExpr = parseTypeExprWithFallback();
+    if (token.kind == TokenKind.COMMA) {
+      expect(TokenKind.COMMA);
+    }
+    int rparenOffset = expect(TokenKind.RPAREN);
+    return new IsInstanceExpression(locs, startOffset, valueExpr, typeExpr, rparenOffset);
+  }
+
   // Parse a list of call arguments.
   //
   // arg_list = ( (arg ',')* arg ','? )?
@@ -754,6 +769,9 @@
       case CAST:
         return parseCastExpression();
 
+      case ISINSTANCE:
+        return parseIsInstanceExpression();
+
       case ELLIPSIS:
         if (!insideTypeExpr) {
           syntaxError("ellipsis ('...') is not allowed outside type expressions");
diff --git a/src/main/java/net/starlark/java/syntax/Resolver.java b/src/main/java/net/starlark/java/syntax/Resolver.java
index 13a81c1..7f23bb9 100644
--- a/src/main/java/net/starlark/java/syntax/Resolver.java
+++ b/src/main/java/net/starlark/java/syntax/Resolver.java
@@ -805,6 +805,14 @@
   }
 
   @Override
+  public void visit(IsInstanceExpression node) {
+    // TODO(b/350661266): restrict the types that can be used on the RHS of isinstance(); e.g.
+    // `list` or `list | tuple` (or aliases resolving to those!) are allowed, but `list[int]` isn't,
+    // since a list can subsequently be mutated to add a non-int element.
+    errorf(node, "isinstance() is not yet supported");
+  }
+
+  @Override
   public void visit(TypeAliasStatement node) {
     if (!(locals.syntax instanceof StarlarkFile)) {
       errorf(node, "type alias statement not at top level");
diff --git a/src/main/java/net/starlark/java/syntax/TokenKind.java b/src/main/java/net/starlark/java/syntax/TokenKind.java
index e964632..8c73cc9 100644
--- a/src/main/java/net/starlark/java/syntax/TokenKind.java
+++ b/src/main/java/net/starlark/java/syntax/TokenKind.java
@@ -68,6 +68,8 @@
   INDENT("indent"),
   INT("integer literal"),
   IS("is"),
+  /** Emitted only if --experimental_starlark_type_syntax is enabled. */
+  ISINSTANCE("isinstance"),
   LAMBDA("lambda"),
   LBRACE("{"),
   LBRACKET("["),
diff --git a/src/test/java/net/starlark/java/eval/EvaluationTest.java b/src/test/java/net/starlark/java/eval/EvaluationTest.java
index 86707d5..84206ea 100644
--- a/src/test/java/net/starlark/java/eval/EvaluationTest.java
+++ b/src/test/java/net/starlark/java/eval/EvaluationTest.java
@@ -907,4 +907,11 @@
         .testEval("y", "\"this is not an int\"")
         .testEval("z", "42");
   }
+
+  // TODO(b/350661266): resolve types in isinstance().
+  @Test
+  public void isinstanceExpression_notYetSupported() throws Exception {
+    ev.setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    ev.new Scenario().testIfExactError("isinstance() is not yet supported", "isinstance(x, list)");
+  }
 }
diff --git a/src/test/java/net/starlark/java/syntax/NodePrinterTest.java b/src/test/java/net/starlark/java/syntax/NodePrinterTest.java
index dd59b9a..d66ef23 100644
--- a/src/test/java/net/starlark/java/syntax/NodePrinterTest.java
+++ b/src/test/java/net/starlark/java/syntax/NodePrinterTest.java
@@ -405,11 +405,18 @@
   @Test
   public void castExpression() throws SyntaxError.Exception {
     setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
-    assertExprPrettyMatches("cast(list[int],foo())", "cast(list[int], foo())");
+    assertExprPrettyMatches("cast(list[int]|str,x+y)", "cast(list[int] | str, x + y)");
     assertExprTostringMatches("cast(set|None,bar(),)", "cast(set | None, bar())");
   }
 
   @Test
+  public void isinstanceExpression() throws SyntaxError.Exception {
+    setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    assertExprPrettyMatches("isinstance(x+y, list|tuple)", "isinstance(x + y, list | tuple)");
+    assertExprTostringMatches("isinstance(foo(), T[U],)", "isinstance(foo(), T[U])");
+  }
+
+  @Test
   public void flowStatement() throws SyntaxError.Exception {
     assertStmtIndentedPrettyMatches(
         """
diff --git a/src/test/java/net/starlark/java/syntax/ParserTest.java b/src/test/java/net/starlark/java/syntax/ParserTest.java
index 55bf7fd..9edc3fc 100644
--- a/src/test/java/net/starlark/java/syntax/ParserTest.java
+++ b/src/test/java/net/starlark/java/syntax/ParserTest.java
@@ -1803,6 +1803,66 @@
   }
 
   @Test
+  public void testIsInstanceExpression_basicFunctionality() throws Exception {
+    setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    IsInstanceExpression cast =
+        (IsInstanceExpression) parseExpression("isinstance(foo(), list | tuple)");
+    assertThat(cast.getType()).isInstanceOf(BinaryOperatorExpression.class);
+    assertThat(cast.getValue()).isInstanceOf(CallExpression.class);
+  }
+
+  @Test
+  public void testIsInstanceExpression_isExpression() throws Exception {
+    setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    parseStatement("if isinstance(isinstance(y, list), bool): isinstance(z, str)");
+  }
+
+  @Test
+  public void testIsInstance_isKeyword() throws Exception {
+    setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    setFailFast(false);
+    assertThat(parseExpressionError("something.isinstance(x, list)"))
+        .contains("syntax error at 'isinstance': expected identifier after dot");
+    assertThat(parseExpressionError("(isinstance)(x, list)")).contains("expected (");
+  }
+
+  @Test
+  public void testIsInstanceExpression_requiresTypeSyntax() throws Exception {
+    // If type syntax is disabled, `isinstance` is treated as an ordinary identifier.
+    setFileOptions(FileOptions.builder().allowTypeSyntax(false).build());
+    assertThat(parseExpression("isinstance(x, T)")).isInstanceOf(CallExpression.class);
+  }
+
+  @Test
+  public void testIsInstanceExpression_goodSyntax() throws Exception {
+    setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    parseExpression(
+        """
+        isinstance(
+            x,
+            T | U[V]
+        )\
+        """);
+    parseExpression("isinstance(x, tuple,)");
+  }
+
+  @Test
+  public void testIsInstanceExpression_badSyntax() throws Exception {
+    setFileOptions(FileOptions.builder().allowTypeSyntax(true).build());
+    setFailFast(false);
+    assertThat(parseExpressionError("isinstance x, int"))
+        .contains("syntax error at 'x': expected (");
+    assertThat(parseExpressionError("isinstance(x, y, int)"))
+        .contains("syntax error at 'int': expected )");
+    assertThat(parseExpressionError("isinstance(x, int"))
+        .contains("syntax error at 'newline': expected )");
+    assertThat(parseExpressionError("isinstance(*args)"))
+        .contains("syntax error at '*': expected expression");
+    assertThat(parseExpressionError("isinstance(value=x, type=int)"))
+        .contains("syntax error at '=': expected ,");
+  }
+
+  @Test
   public void testLambda() throws Exception {
     parseExpression("lambda a, b=1, *args, **kwargs: a+b");
     parseExpression("lambda *, a, *b: 0");
diff --git a/src/test/java/net/starlark/java/syntax/ResolverTest.java b/src/test/java/net/starlark/java/syntax/ResolverTest.java
index 65b467d..6a68f01 100644
--- a/src/test/java/net/starlark/java/syntax/ResolverTest.java
+++ b/src/test/java/net/starlark/java/syntax/ResolverTest.java
@@ -794,6 +794,15 @@
     assertThat(badFile.ok()).isTrue();
   }
 
+  // TODO(b/350661266): resolve types in isinstance().
+  @Test
+  public void testIsInstanceExpression_notYetSupported() throws Exception {
+    options.allowTypeSyntax(true);
+    StarlarkFile badFile = resolveFile("isinstance(x, list)");
+    assertThat(badFile.ok()).isFalse();
+    assertContainsError(badFile.errors(), "isinstance() is not yet supported");
+  }
+
   // checkBindings verifies the binding (scope and index) of each identifier.
   // Every variable must be followed by a superscript letter (its scope)
   // and a subscript numeral (its index). They are replaced by spaces, the