diff --git a/src/index.ts b/src/index.ts
index 1a0f1b4c82..fb67b4c75e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -355,6 +355,7 @@ export {
   ValidationContext,
   // All validation rules in the GraphQL Specification.
   specifiedRules,
+  recommendedRules,
   // Individual validation rules.
   ExecutableDefinitionsRule,
   FieldsOnCorrectTypeRule,
@@ -382,6 +383,7 @@ export {
   ValuesOfCorrectTypeRule,
   VariablesAreInputTypesRule,
   VariablesInAllowedPositionRule,
+  MaxIntrospectionDepthRule,
   // SDL-specific validation rules
   LoneSchemaDefinitionRule,
   UniqueOperationTypesRule,
diff --git a/src/validation/__tests__/MaxIntrospectionDepthRule-test.ts b/src/validation/__tests__/MaxIntrospectionDepthRule-test.ts
new file mode 100644
index 0000000000..ff6826c873
--- /dev/null
+++ b/src/validation/__tests__/MaxIntrospectionDepthRule-test.ts
@@ -0,0 +1,554 @@
+import { describe, it } from 'mocha';
+
+import { getIntrospectionQuery } from '../../utilities/getIntrospectionQuery.js';
+
+import { MaxIntrospectionDepthRule } from '../rules/MaxIntrospectionDepthRule.js';
+
+import { expectValidationErrors } from './harness.js';
+
+function expectErrors(queryStr: string) {
+  return expectValidationErrors(MaxIntrospectionDepthRule, queryStr);
+}
+
+function expectValid(queryStr: string) {
+  expectErrors(queryStr).toDeepEqual([]);
+}
+
+describe('Validate: Max introspection nodes rule', () => {
+  it('default introspection query', () => {
+    expectValid(getIntrospectionQuery());
+  });
+
+  it('all options introspection query', () => {
+    expectValid(
+      getIntrospectionQuery({
+        descriptions: true,
+        specifiedByUrl: true,
+        directiveIsRepeatable: true,
+        schemaDescription: true,
+        inputValueDeprecation: true,
+      }),
+    );
+  });
+
+  it('3 flat fields introspection query', () => {
+    expectValid(`
+    {
+      __type(name: "Query") {
+        trueFields: fields(includeDeprecated: true) {
+          name
+        }
+        falseFields: fields(includeDeprecated: false) {
+          name
+        }
+        omittedFields: fields {
+          name
+        }
+      }
+    }
+    `);
+  });
+
+  it('3 fields deep introspection query from __schema', () => {
+    expectErrors(`
+    {
+      __schema {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 interfaces deep introspection query from __schema', () => {
+    expectErrors(`
+    {
+      __schema {
+        types {
+          interfaces {
+            interfaces {
+              interfaces {
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 possibleTypes deep introspection query from __schema', () => {
+    expectErrors(`
+    {
+      __schema {
+        types {
+          possibleTypes {
+            possibleTypes {
+              possibleTypes {
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 inputFields deep introspection query from __schema', () => {
+    expectErrors(`
+    {
+      __schema {
+        types {
+          inputFields {
+            type {
+              inputFields {
+                type {
+                  inputFields {
+                    type {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 fields deep introspection query from multiple __schema', () => {
+    expectErrors(`
+    {
+      one: __schema {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      two: __schema {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      three: __schema {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+      {
+        locations: [
+          {
+            column: 7,
+            line: 18,
+          },
+        ],
+        message: 'Maximum introspection depth exceeded',
+      },
+      {
+        locations: [
+          {
+            column: 7,
+            line: 33,
+          },
+        ],
+        message: 'Maximum introspection depth exceeded',
+      },
+    ]);
+  });
+
+  it('3 fields deep introspection query from __type', () => {
+    expectErrors(`
+    {
+      __type(name: "Query") {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 fields deep introspection query from multiple __type', () => {
+    expectErrors(`
+    {
+      one: __type(name: "Query") {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      two: __type(name: "Query") {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      three: __type(name: "Query") {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  fields {
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+      {
+        locations: [
+          {
+            column: 7,
+            line: 18,
+          },
+        ],
+        message: 'Maximum introspection depth exceeded',
+      },
+      {
+        locations: [
+          {
+            column: 7,
+            line: 33,
+          },
+        ],
+        message: 'Maximum introspection depth exceeded',
+      },
+    ]);
+  });
+
+  it('1 fields deep with 3 fields introspection query', () => {
+    expectValid(`
+    {
+      __schema {
+        types {
+          fields {
+            type {
+              oneFields: fields {
+                name
+              }
+              twoFields: fields {
+                name
+              }
+              threeFields: fields {
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+    `);
+  });
+
+  it('3 fields deep from varying parents introspection query', () => {
+    expectErrors(`
+    {
+      __schema {
+        types {
+          fields {
+            type {
+              fields {
+                type {
+                  ofType {
+                    fields {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 fields deep introspection query with inline fragments', () => {
+    expectErrors(`
+    query test {
+      __schema {
+        types {
+          ... on __Type {
+            fields {
+              type {
+                ... on __Type {
+                  ofType {
+                    fields {
+                      type {
+                        ... on __Type {
+                          fields {
+                            name
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 fields deep introspection query with fragments', () => {
+    expectErrors(`
+    query test {
+      __schema {
+        types {
+          ...One
+        }
+      }
+    }
+
+    fragment One on __Type {
+      fields {
+        type {
+          ...Two
+        }
+      }
+    }
+
+    fragment Two on __Type {
+      fields {
+        type {
+          ...Three
+        }
+      }
+    }
+
+    fragment Three on __Type {
+      fields {
+        name
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 7,
+            line: 3,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('3 fields deep inside inline fragment on query', () => {
+    expectErrors(`
+    {
+      ... {
+        __schema { types { fields { type { fields { type { fields { name } } } } } } }
+      }
+    }
+    `).toDeepEqual([
+      {
+        message: 'Maximum introspection depth exceeded',
+        locations: [
+          {
+            column: 9,
+            line: 4,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('opts out if fragment is missing', () => {
+    expectValid(`
+    query test {
+      __schema {
+        types {
+          ...Missing
+        }
+      }
+    }
+    `);
+  });
+
+  it("doesn't infinitely recurse on fragment cycle", () => {
+    expectValid(`
+    query test {
+      __schema {
+        types {
+          ...Cycle
+        }
+      }
+    }
+    fragment Cycle on __Type {
+      ...Cycle
+    }
+    `);
+  });
+});
diff --git a/src/validation/index.ts b/src/validation/index.ts
index b0cc754490..dbe8e57dc0 100644
--- a/src/validation/index.ts
+++ b/src/validation/index.ts
@@ -4,7 +4,7 @@ export { ValidationContext } from './ValidationContext.js';
 export type { ValidationRule } from './ValidationContext.js';
 
 // All validation rules in the GraphQL Specification.
-export { specifiedRules } from './specifiedRules.js';
+export { specifiedRules, recommendedRules } from './specifiedRules.js';
 
 // Spec Section: "Defer And Stream Directive Labels Are Unique"
 export { DeferStreamDirectiveLabelRule } from './rules/DeferStreamDirectiveLabelRule.js';
@@ -96,6 +96,8 @@ export { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.j
 // Spec Section: "All Variable Usages Are Allowed"
 export { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.js';
 
+export { MaxIntrospectionDepthRule } from './rules/MaxIntrospectionDepthRule.js';
+
 // SDL-specific validation rules
 export { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.js';
 export { UniqueOperationTypesRule } from './rules/UniqueOperationTypesRule.js';
diff --git a/src/validation/rules/MaxIntrospectionDepthRule.ts b/src/validation/rules/MaxIntrospectionDepthRule.ts
new file mode 100644
index 0000000000..5cde22f130
--- /dev/null
+++ b/src/validation/rules/MaxIntrospectionDepthRule.ts
@@ -0,0 +1,92 @@
+import { GraphQLError } from '../../error/GraphQLError.js';
+
+import type { ASTNode } from '../../language/ast.js';
+import { Kind } from '../../language/kinds.js';
+import type { ASTVisitor } from '../../language/visitor.js';
+
+import type { ValidationContext } from '../ValidationContext.js';
+
+const MAX_LISTS_DEPTH = 3;
+
+export function MaxIntrospectionDepthRule(
+  context: ValidationContext,
+): ASTVisitor {
+  /**
+   * Counts the depth of list fields in "__Type" recursively and
+   * returns `true` if the limit has been reached.
+   */
+  function checkDepth(
+    node: ASTNode,
+    visitedFragments: {
+      [fragmentName: string]: true | undefined;
+    } = Object.create(null),
+    depth: number = 0,
+  ): boolean {
+    if (node.kind === Kind.FRAGMENT_SPREAD) {
+      const fragmentName = node.name.value;
+      if (visitedFragments[fragmentName] === true) {
+        // Fragment cycles are handled by `NoFragmentCyclesRule`.
+        return false;
+      }
+      const fragment = context.getFragment(fragmentName);
+      if (!fragment) {
+        // Missing fragments checks are handled by the `KnownFragmentNamesRule`.
+        return false;
+      }
+
+      // Rather than following an immutable programming pattern which has
+      // significant memory and garbage collection overhead, we've opted to
+      // take a mutable approach for efficiency's sake. Importantly visiting a
+      // fragment twice is fine, so long as you don't do one visit inside the
+      // other.
+      try {
+        visitedFragments[fragmentName] = true;
+        return checkDepth(fragment, visitedFragments, depth);
+      } finally {
+        visitedFragments[fragmentName] = undefined;
+      }
+    }
+
+    if (
+      node.kind === Kind.FIELD &&
+      // check all introspection lists
+      // TODO: instead of relying on field names, check whether the type is a list
+      (node.name.value === 'fields' ||
+        node.name.value === 'interfaces' ||
+        node.name.value === 'possibleTypes' ||
+        node.name.value === 'inputFields')
+    ) {
+      // eslint-disable-next-line no-param-reassign
+      depth++;
+      if (depth >= MAX_LISTS_DEPTH) {
+        return true;
+      }
+    }
+
+    // handles fields and inline fragments
+    if ('selectionSet' in node && node.selectionSet) {
+      for (const child of node.selectionSet.selections) {
+        if (checkDepth(child, visitedFragments, depth)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return {
+    Field(node) {
+      if (node.name.value === '__schema' || node.name.value === '__type') {
+        if (checkDepth(node)) {
+          context.reportError(
+            new GraphQLError('Maximum introspection depth exceeded', {
+              nodes: [node],
+            }),
+          );
+          return false;
+        }
+      }
+    },
+  };
+}
diff --git a/src/validation/specifiedRules.ts b/src/validation/specifiedRules.ts
index 60c967f8f0..9884bea8b9 100644
--- a/src/validation/specifiedRules.ts
+++ b/src/validation/specifiedRules.ts
@@ -25,6 +25,8 @@ import { KnownTypeNamesRule } from './rules/KnownTypeNamesRule.js';
 import { LoneAnonymousOperationRule } from './rules/LoneAnonymousOperationRule.js';
 // SDL-specific validation rules
 import { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.js';
+// TODO: Spec Section
+import { MaxIntrospectionDepthRule } from './rules/MaxIntrospectionDepthRule.js';
 // Spec Section: "Fragments must not form cycles"
 import { NoFragmentCyclesRule } from './rules/NoFragmentCyclesRule.js';
 // Spec Section: "All Variable Used Defined"
@@ -75,6 +77,12 @@ import { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.j
 import { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.js';
 import type { SDLValidationRule, ValidationRule } from './ValidationContext.js';
 
+/**
+ * Technically these aren't part of the spec but they are strongly encouraged
+ * validation rules.
+ */
+export const recommendedRules = Object.freeze([MaxIntrospectionDepthRule]);
+
 /**
  * This set includes all validation rules defined by the GraphQL spec.
  *
@@ -112,6 +120,7 @@ export const specifiedRules: ReadonlyArray<ValidationRule> = Object.freeze([
   VariablesInAllowedPositionRule,
   OverlappingFieldsCanBeMergedRule,
   UniqueInputFieldNamesRule,
+  ...recommendedRules,
 ]);
 
 /**