@@ -16,6 +16,12 @@ This driver uses semantic versioning:
 
 ## [Unreleased]
 
+### Fixed
+
+- Graph creation: Send `isSmart` inside the HTTP request body's `options` object
+  in `graph.create` and `db.createGraph`, alongside `isDisjoint` (DE-1246).
+  The driver's options argument and returned graph metadata remain unchanged.
+
 ## [10.6.0] - 2026-10-14
 
 ### Added
 
@@ -284,7 +284,10 @@ export type EdgeDefinition = {
 
 //#region Graph operation options
 /**
- * Option for creating a graph.
+ * Options for creating a graph.
+ *
+ * SmartGraphs, EnterpriseGraphs, and SatelliteGraphs require a cluster and,
+ * before ArangoDB 3.12.5, Enterprise Edition.
  */
 export type CreateGraphOptions = {
   /**
@@ -326,27 +329,32 @@ export type CreateGraphOptions = {
 
   // Extra options
   /**
-   * (Enterprise Edition cluster only.) If set to `true`, the graph will be
-   * created as a SmartGraph.
+   * (Cluster only.) If set to `true` without a `smartGraphAttribute`, the graph
+   * will be created as an EnterpriseGraph. Setting `smartGraphAttribute` creates
+   * a SmartGraph and automatically enables `isSmart`.
+   *
+   * Has no effect when `replicationFactor` is set to `"satellite"`, which creates
+   * a SatelliteGraph.
    *
    * Default: `false`
    */
   isSmart?: boolean;
   /**
-   * (Enterprise Edition cluster only.) Attribute containing the shard key
-   * value to use for smart sharding.
+   * (Cluster only.) Attribute containing the shard key value to use for smart
+   * sharding. Setting this option creates a SmartGraph, even if `isSmart` is
+   * omitted. Every vertex must have this attribute. Cannot be modified later.
    */
   smartGraphAttribute?: string;
   /**
-   * (Enterprise Edition cluster only.) If set to `true`, the graph will be
-   * created as a Disjoint SmartGraph.
+   * (Cluster only.) If set to `true`, the graph will be created as a Disjoint
+   * SmartGraph. Only has an effect in combination with `smartGraphAttribute`
+   * or `isSmart`.
    *
    * Default: `false`
    */
   isDisjoint?: boolean;
   /**
-   * (Enterprise Edition cluster only.) Collections to be included in a Hybrid
-   * SmartGraph.
+   * (Cluster only.) Collections to be included in a Hybrid SmartGraph.
    */
   satellites?: (string | collections.ArangoCollection)[];
 };
@@ -1359,6 +1367,9 @@ export class Graph {
    * Creates a graph with the given `edgeDefinitions` and `options` for this
    * graph's name.
    *
+   * `isSmart` and `isDisjoint` are passed directly in `options` and sent inside
+   * the HTTP request body's `options` object.
+   *
    * @param edgeDefinitions - Definitions for the relations of the graph.
    * @param options - Options for creating the graph.
    *
@@ -1375,13 +1386,23 @@ export class Graph {
    * ]);
    * // graph now exists
    * ```
+   *
+   * @example
+   * ```js
+   * const db = new Database();
+   * const graph = db.graph("enterprise-graph");
+   * await graph.create(
+   *   [{ collection: "edges", from: ["vertices"], to: ["vertices"] }],
+   *   { isSmart: true, numberOfShards: 3 }
+   * );
+   * // Creates an EnterpriseGraph in a cluster without a smartGraphAttribute.
+   * ```
    */
   create(
     edgeDefinitions: EdgeDefinitionOptions[],
     options: CreateGraphOptions = {}
   ): Promise<GraphDescription> {
-    const { orphanCollections, satellites, waitForSync, isSmart, ...opts } =
-      options;
+    const { orphanCollections, satellites, waitForSync, ...opts } = options;
     return this._db.request(
       {
         method: "POST",
@@ -1393,7 +1414,6 @@ export class Graph {
               ? orphanCollections.map(collections.collectionToString)
               : [collections.collectionToString(orphanCollections)]),
           edgeDefinitions: edgeDefinitions.map(coerceEdgeDefinition),
-          isSmart,
           name: this._name,
           options: {
             ...opts,
 
@@ -36,6 +36,32 @@ describe("Accessing graphs", function () {
       expect(graph).to.have.property("name").that.equals(name);
     });
   });
+  describe("database.createGraph", () => {
+    it("creates a graph and returns its handle", async () => {
+      const name = `created_graph_${Date.now()}`;
+      const orphan = db.collection(`${name}_orphan`);
+      const graph = db.graph(name);
+      try {
+        expect(
+          await db.createGraph(name, [], {
+            orphanCollections: orphan,
+            isSmart: false,
+            isDisjoint: false,
+          }),
+        ).to.equal(graph);
+        await db.waitForPropagation(
+          { pathname: `/_api/gharial/${name}` },
+          propagationForResourceMs,
+        );
+        const data = await graph.get();
+        expect(data.name).to.equal(name);
+        expect(data.orphanCollections).to.deep.equal([orphan.name]);
+      } finally {
+        if (await graph.exists()) await graph.drop(true);
+        if (await orphan.exists()) await orphan.drop();
+      }
+    });
+  });
   describe("database.listGraphs", () => {
     const vertexCollectionNames = range(2).map((i) => `vc_${Date.now()}_${i}`);
     const edgeCollectionNames = range(2).map((i) => `ec_${Date.now()}_${i}`);
 
@@ -1,6 +1,9 @@
 import { expect } from "chai";
 import { Database } from "../databases.js";
-import { Graph } from "../graphs.js";
+import { isArangoError } from "../errors.js";
+import { Graph, type CreateGraphOptions } from "../graphs.js";
+import { GRAPH_NOT_FOUND } from "../lib/codes.js";
+import { versionStringToArangoVersionCode } from "./_arango-server-version.js";
 import { config } from "./_config.js";
 import {
   clusterIntegrationTimeoutMs,
@@ -123,6 +126,153 @@ describe("Graph API", function () {
       expect(data).to.have.property("name", graph.name);
     });
   });
+  describe("graph.create advanced graph options", function () {
+    let graph: Graph;
+    let collectionNames: string[];
+    let sequence = 0;
+
+    before(async function () {
+      const version = await system.version();
+      const { role } = await system.request<{ role: string }>({
+        pathname: "/_admin/server/role",
+      });
+      // Community Edition includes these features from 3.12.5 onward.
+      // https://docs.arango.ai/arangodb/3.12/release-notes/version-3.12/whats-new-in-3-12/
+      if (
+        role !== "COORDINATOR" ||
+        (version.license !== "enterprise" &&
+          versionStringToArangoVersionCode(version.version) < 31205)
+      ) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `Skipping advanced graph creation: ArangoDB ${version.version}, ${version.license}, role ${role} requires a cluster with smart graph support.`,
+        );
+        this.skip();
+      }
+    });
+
+    beforeEach(() => {
+      const prefix = `graph_options_${Date.now()}_${sequence++}`;
+      graph = db.graph(prefix);
+      collectionNames = ["edges", "start", "end", "orphan"].map(
+        (suffix) => `${prefix}_${suffix}`,
+      );
+    });
+
+    afterEach(async () => {
+      try {
+        await graph.drop(true);
+      } catch (error) {
+        if (!isArangoError(error) || error.errorNum !== GRAPH_NOT_FOUND) {
+          throw error;
+        }
+      } finally {
+        // A failed create can leave collections without a graph definition.
+        for (const name of collectionNames) {
+          const collection = db.collection(name);
+          if (await collection.exists()) await collection.drop();
+        }
+      }
+    });
+
+    const cases: {
+      title: string;
+      options: CreateGraphOptions;
+      expected: Record<string, unknown>;
+      satellite?: boolean;
+    }[] = [
+      {
+        title: "creates an EnterpriseGraph without a smart attribute",
+        options: { isSmart: true },
+        expected: { isSmart: true, isSatellite: false, isDisjoint: false },
+      },
+      {
+        title: "creates a SmartGraph with explicit isSmart",
+        options: { isSmart: true, smartGraphAttribute: "region" },
+        expected: {
+          isSmart: true,
+          isSatellite: false,
+          smartGraphAttribute: "region",
+          isDisjoint: false,
+        },
+      },
+      {
+        title: "creates a SmartGraph from the smart attribute alone",
+        options: { smartGraphAttribute: "region" },
+        expected: {
+          isSmart: true,
+          isSatellite: false,
+          smartGraphAttribute: "region",
+          isDisjoint: false,
+        },
+      },
+      {
+        title: "creates a Disjoint SmartGraph",
+        options: {
+          isSmart: true,
+          smartGraphAttribute: "region",
+          isDisjoint: true,
+        },
+        expected: {
+          isSmart: true,
+          isSatellite: false,
+          smartGraphAttribute: "region",
+          isDisjoint: true,
+        },
+      },
+      {
+        title: "creates a SmartGraph with a satellite vertex collection",
+        options: { isSmart: true, smartGraphAttribute: "region" },
+        expected: {
+          isSmart: true,
+          isSatellite: false,
+          smartGraphAttribute: "region",
+        },
+        satellite: true,
+      },
+      {
+        title: "creates a SatelliteGraph when isSmart is also true",
+        options: { isSmart: true, replicationFactor: "satellite" },
+        expected: { isSmart: false, isSatellite: true },
+      },
+    ];
+
+    for (const { title, options, expected, satellite } of cases) {
+      it(title, async () => {
+        const [edges, start, end, orphan] = collectionNames;
+        const created = await graph.create(
+          [{ collection: edges, from: [start], to: [end] }],
+          {
+            ...(options.replicationFactor === "satellite"
+              ? {}
+              : { numberOfShards: 2, replicationFactor: 1 }),
+            ...options,
+            orphanCollections: [orphan],
+            ...(satellite ? { satellites: [db.collection(end)] } : {}),
+          },
+        );
+        await db.waitForPropagation(
+          { pathname: `/_api/gharial/${graph.name}` },
+          propagationForResourceMs,
+        );
+        for (const data of [created, await graph.get()]) {
+          expect(data).to.include({ name: graph.name, ...expected });
+          expect(data.orphanCollections).to.include(orphan);
+          if (!options.smartGraphAttribute) {
+            expect(data.smartGraphAttribute).to.be.undefined;
+          }
+        }
+        if (satellite) {
+          await db.waitForPropagation(
+            { pathname: `/_api/collection/${end}` },
+            propagationForResourceMs,
+          );
+          const properties = await db.collection(end).properties();
+          expect(properties.replicationFactor).to.equal("satellite");
+        }
+      });
+    }
+  });
   describe("graph.drop", () => {
     let graph: Graph;
     let edgeCollectionNames: string[];