Schema Explorer

What is Schema Introspection?

GraphQL APIs are self-describing. Every GraphQL server can be asked about its schema - what types exist, what fields they have, what arguments are available. This is called introspection.

How Atrahasis Uses This

When you enter a GraphQL URL, Atrahasis automatically fetches the schema and displays it in an interactive tree view. You can browse all available queries, mutations, and types without reading documentation.

Fetching the Schema

The schema is loaded automatically when you enter or change the URL:

1

Enter GraphQL Endpoint URL

Type or paste the URL in the request bar. After 500ms of no typing, schema fetch begins automatically.

2

Introspection Query Sent

Atrahasis sends a standard GraphQL introspection query to discover all types and fields. It goes out with the same auth, custom headers, and environment variable resolution as a real query from this tab.

✓

Schema Tree Displayed

Query, Mutation, and Subscription roots appear in the explorer. Expand them to see available fields.

FetchClick to manually refresh the schema

Authentication May Be Required

Some GraphQL APIs require authentication for introspection. If schema fetch fails, configure auth in the Auth tab first, then click "Fetch" again.

Schema Tree Structure

The schema is displayed as an expandable tree:

▼Query
▶users(limit: Int): [User!]!
▶user(id: ID!): User
currentUser: User
▶Mutation
▶Subscription

Root Types

  • • Query - Read operations
  • • Mutation - Write operations
  • • Subscription - Real-time subscriptions

Field Info

  • • Field name - The field to query
  • • (args) - Required/optional arguments
  • • : Type - Return type

Understanding Type Notation

GraphQL types use special notation to indicate nullability and lists:

TypeMeaningExample
StringNullable stringCan be null or "hello"
String!Non-null stringAlways a string, never null
[String]Nullable list of nullable stringsnull, [], ["a", null, "b"]
[String!]Nullable list of non-null stringsnull, [], ["a", "b"]
[String!]!Non-null list of non-null strings[], ["a", "b"] (never null)

Selecting Fields

Click checkboxes to select fields. The query is generated automatically:

Selected in Explorer

▼Query
▼users
id
name
email

Generated Query

query {
users {
id
name
}
}

Auto-Selection

When you select a field that returns an object type (like users), Atrahasis automatically selects all its scalar fields (id, name, etc.) and expands the node. Nested object fields are left unselected on purpose: schemas are full of cycles (User to Post to User again), so following them would generate an endless query. Open those yourself when you want them.

Deselecting Cleans Up

Unticking a field also removes every selection underneath it, so you never leave orphaned child fields behind in the generated query.

Field Arguments

When you select a field with arguments, input fields appear:

users(...)
limit:Int
offset:Int

Enter argument values directly in the explorer. These become query variables, named after the field and the argument together so two fields taking the same argument never collide. The operation itself is named after the first field you selected:

# Query
query Users($users_limit: Int) {
users(limit: $users_limit) {
id name
}
}
# Variables
{
"users_limit": 10
}

The declared type comes straight from the schema with its wrappers intact, so an ID! argument is declared ID!. Values are read as JSON where they can be, so 10 arrives as a number and true as a boolean, falling back to a string otherwise.

Required Arguments Appear Even When Empty

An argument marked * is written into the query before you fill it in. That keeps the document structurally valid and lets the server tell you exactly what is missing, instead of the field silently disappearing from the query and failing validation for a confusing reason.

Input Object Arguments

When an argument's type is an input object, the row expands into that object's own fields, nested as deep as the input types go. Fill in the leaves you care about and Atrahasis assembles them into an inline object in the query rather than a variable:

In the explorer
createUser
input * CreateUserInput!
name:
# Generated
mutation {
createUser(input: { name: "John" }) {
id
}
}

Schema Search

Use the search field to quickly find fields in large schemas:

Fetch

Type to search. Matching fields are highlighted and their parent nodes auto-expand. Search is debounced (150ms) for performance.

Search runs against the whole fetched schema, not just the part of the tree currently on screen, so a field inside a type you have never expanded is still found. The parents needed to reach it are expanded and loaded for you, and the tree is filtered down to the branches that contain a match. Nested types are searched two levels deep, which is what keeps a search for a common name like id from returning the entire graph.

Performance: Lazy Loading

Large GraphQL schemas can have hundreds of types. Atrahasis uses lazy loading:

  • Root types loaded immediately - Query, Mutation, Subscription appear right away
  • Nested fields loaded on expand - Child fields load when you click to expand a node
  • Schema cached per URL - Expanding nodes reads the cached schema instead of going back to the network. Editing the URL back to one already fetched does not refetch, while the Fetch button always requests a fresh schema
  • Cache is per tab - Switching tabs clears it, so one tab's schema never appears in another pointed at a different API
The InterfaceWriting Queries