diff --git a/README.md b/README.md
index af24cad..31f0c3c 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Possible use-cases:
 | :white_check_mark: | User Notifications |
 | :white_check_mark: | User |
 | :x: | Creator Store |
-| :x: | Luau Execution |
+| :white_check_mark: | Luau Execution |
 
 - :white_check_mark: = Supported
 - :x: = Not yet supported
diff --git a/docs/cli/cli-luau-execution.md b/docs/cli/cli-luau-execution.md
new file mode 100644
index 0000000..48c926d
--- /dev/null
+++ b/docs/cli/cli-luau-execution.md
@@ -0,0 +1,54 @@
+# Luau Execution API
+
+# Execute Task
+Executes Luau code on Roblox.
+```
+Usage: rbxcloud luau execute [OPTIONS] --universe-id <UNIVERSE_ID> --place-id <PLACE_ID> --api-key <API_KEY>
+
+Options:
+  -u, --universe-id <UNIVERSE_ID>  Universe ID of the experience
+  -i, --place-id <PLACE_ID>        Place ID of the experience
+  -r, --version-id <VERSION_ID>    Version ID of the experience
+  -s, --script <SCRIPT>            Script source code
+  -f, --filepath <FILEPATH>        Script source code file
+  -t, --timeout <TIMEOUT>          Execution timeout
+  -p, --pretty                     Pretty-print the JSON response
+  -a, --api-key <API_KEY>          Roblox Open Cloud API Key [env: RBXCLOUD_API_KEY=]
+  -h, --help                       Print help
+```
+
+## Get Task Information
+Gets information on a previously executed task.
+
+```
+Usage: rbxcloud luau get-task [OPTIONS] --universe-id <UNIVERSE_ID> --place-id <PLACE_ID> --session-id <SESSION_ID> --task-id <TASK_ID> --api-key <API_KEY>
+
+Options:
+  -u, --universe-id <UNIVERSE_ID>  Universe ID of the experience
+  -i, --place-id <PLACE_ID>        Place ID of the experience
+  -r, --version-id <VERSION_ID>    Version ID of the experience
+  -s, --session-id <SESSION_ID>    Luau execution session ID
+  -t, --task-id <TASK_ID>          Luau execution task ID
+  -p, --pretty                     Pretty-print the JSON response
+  -a, --api-key <API_KEY>          Roblox Open Cloud API Key [env: RBXCLOUD_API_KEY=]
+  -h, --help                       Print help
+```
+
+## Get Task Logs
+Retrieves logs on a previously executed task.
+```
+Usage: rbxcloud.exe luau get-logs [OPTIONS] --universe-id <UNIVERSE_ID> --place-id <PLACE_ID> --session-id <SESSION_ID> --task-id <TASK_ID> --api-key <API_KEY>
+
+Options:
+  -u, --universe-id <UNIVERSE_ID>      Universe ID of the experience
+  -i, --place-id <PLACE_ID>            Place ID of the experience
+  -r, --version-id <VERSION_ID>        Version ID of the experience
+  -s, --session-id <SESSION_ID>        Luau execution session ID
+  -t, --task-id <TASK_ID>              Luau execution task ID
+  -m, --max-page-size <MAX_PAGE_SIZE>  Max page size
+  -n, --page-token <PAGE_TOKEN>        Next page token
+  -w, --view <VIEW>                    Log view type [possible values: flat, structured]
+  -p, --pretty                         Pretty-print the JSON response
+  -a, --api-key <API_KEY>              Roblox Open Cloud API Key [env: RBXCLOUD_API_KEY=]
+  -h, --help                           Print help
+```
diff --git a/mkdocs.yml b/mkdocs.yml
index c9de1a0..1b2c5b0 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -8,16 +8,17 @@ nav:
   - Home: index.md
   - CLI:
     - Install: cli/cli-install.md
-    - Assets: cli/cli-assets.md
     - API Key: cli/cli-api-key.md
-    - Experience: cli/cli-experience.md
-    - Messaging: cli/cli-messaging.md
+    - Assets: cli/cli-assets.md
     - DataStore: cli/cli-datastore.md
-    - OrderedDataStore: cli/cli-ordered-datastore.md
+    - Experience: cli/cli-experience.md
     - Group: cli/cli-group.md
-    - Subscription: cli/cli-subscription.md
+    - Luau Execution: cli/cli-luau-execution.md
+    - Messaging: cli/cli-messaging.md
     - Notification: cli/cli-notification.md
+    - OrderedDataStore: cli/cli-ordered-datastore.md
     - Place: cli/cli-place.md
+    - Subscription: cli/cli-subscription.md
     - Universe: cli/cli-universe.md
     - User: cli/cli-user.md
   - Rust Lib:
diff --git a/src/cli/luau_execution_cli.rs b/src/cli/luau_execution_cli.rs
new file mode 100644
index 0000000..f8d5bdb
--- /dev/null
+++ b/src/cli/luau_execution_cli.rs
@@ -0,0 +1,237 @@
+use clap::{Args, Subcommand};
+use rbxcloud::rbx::{
+    types::{PlaceId, UniverseId},
+    v2::{luau_execution::LuauExecutionTaskLogView, Client},
+};
+use tokio::fs;
+
+#[derive(Debug, Subcommand)]
+pub enum LuauExecutionCommands {
+    /// Executes Luau code on Roblox
+    Execute {
+        /// Universe ID of the experience
+        #[clap(short, long, value_parser)]
+        universe_id: u64,
+
+        /// Place ID of the experience
+        #[clap(short = 'i', long, value_parser)]
+        place_id: u64,
+
+        /// Version ID of the experience
+        #[clap(short = 'r', long, value_parser)]
+        version_id: Option<String>,
+
+        /// Script source code
+        #[clap(short, long, value_parser)]
+        script: Option<String>,
+
+        /// Script source code file
+        #[clap(short, long, value_parser)]
+        filepath: Option<String>,
+
+        /// Execution timeout
+        #[clap(short, long, value_parser)]
+        timeout: Option<String>,
+
+        /// Pretty-print the JSON response
+        #[clap(short, long, value_parser, default_value_t = false)]
+        pretty: bool,
+
+        /// Roblox Open Cloud API Key
+        #[clap(short, long, value_parser, env = "RBXCLOUD_API_KEY")]
+        api_key: String,
+    },
+
+    /// Gets information on a previously executed task
+    GetTask {
+        /// Universe ID of the experience
+        #[clap(short, long, value_parser)]
+        universe_id: u64,
+
+        /// Place ID of the experience
+        #[clap(short = 'i', long, value_parser)]
+        place_id: u64,
+
+        /// Version ID of the experience
+        #[clap(short = 'r', long, value_parser)]
+        version_id: Option<String>,
+
+        /// Luau execution session ID
+        #[clap(short, long, value_parser)]
+        session_id: String,
+
+        /// Luau execution task ID
+        #[clap(short, long, value_parser)]
+        task_id: String,
+
+        /// Pretty-print the JSON response
+        #[clap(short, long, value_parser, default_value_t = false)]
+        pretty: bool,
+
+        /// Roblox Open Cloud API Key
+        #[clap(short, long, value_parser, env = "RBXCLOUD_API_KEY")]
+        api_key: String,
+    },
+
+    /// Retrieves logs on a previously executed task
+    GetLogs {
+        /// Universe ID of the experience
+        #[clap(short, long, value_parser)]
+        universe_id: u64,
+
+        /// Place ID of the experience
+        #[clap(short = 'i', long, value_parser)]
+        place_id: u64,
+
+        /// Version ID of the experience
+        #[clap(short = 'r', long, value_parser)]
+        version_id: Option<String>,
+
+        /// Luau execution session ID
+        #[clap(short, long, value_parser)]
+        session_id: String,
+
+        /// Luau execution task ID
+        #[clap(short, long, value_parser)]
+        task_id: String,
+
+        /// Max page size
+        #[clap(short, long, value_parser)]
+        max_page_size: Option<u32>,
+
+        /// Next page token
+        #[clap(short = 'n', long, value_parser)]
+        page_token: Option<String>,
+
+        /// Log view type
+        #[clap(short = 'w', long, value_enum)]
+        view: Option<LuauExecutionTaskLogView>,
+
+        /// Pretty-print the JSON response
+        #[clap(short, long, value_parser, default_value_t = false)]
+        pretty: bool,
+
+        /// Roblox Open Cloud API Key
+        #[clap(short, long, value_parser, env = "RBXCLOUD_API_KEY")]
+        api_key: String,
+    },
+}
+
+#[derive(Debug, Args)]
+pub struct Luau {
+    #[clap(subcommand)]
+    command: LuauExecutionCommands,
+}
+
+impl Luau {
+    pub async fn run(self) -> anyhow::Result<Option<String>> {
+        match self.command {
+            LuauExecutionCommands::Execute {
+                universe_id,
+                place_id,
+                version_id,
+                script,
+                filepath,
+                timeout,
+                pretty,
+                api_key,
+            } => {
+                let client = Client::new(&api_key);
+
+                let luau = client.luau(UniverseId(universe_id), PlaceId(place_id), version_id);
+
+                let mut script_source: Option<String> = None;
+                if script.is_some() {
+                    script_source = script;
+                }
+
+                if script_source.is_none() {
+                    if let Some(path) = filepath {
+                        let src_bytes = fs::read(path).await?;
+                        script_source = Some(String::from_utf8(src_bytes)?);
+                    }
+                }
+
+                let src = script_source.expect("script or filepath must be set");
+
+                let res = luau.create_task(src, timeout).await;
+                match res {
+                    Ok(data) => {
+                        let r = if pretty {
+                            serde_json::to_string_pretty(&data)?
+                        } else {
+                            serde_json::to_string(&data)?
+                        };
+                        Ok(Some(r))
+                    }
+                    Err(err) => Err(anyhow::anyhow!(err)),
+                }
+            }
+
+            LuauExecutionCommands::GetTask {
+                universe_id,
+                place_id,
+                version_id,
+                session_id,
+                task_id,
+                pretty,
+                api_key,
+            } => {
+                let client = Client::new(&api_key);
+
+                let luau = client.luau(UniverseId(universe_id), PlaceId(place_id), version_id);
+
+                let res = luau.get_task(session_id, task_id).await;
+                match res {
+                    Ok(data) => {
+                        let r = if pretty {
+                            serde_json::to_string_pretty(&data)?
+                        } else {
+                            serde_json::to_string(&data)?
+                        };
+                        Ok(Some(r))
+                    }
+                    Err(err) => Err(anyhow::anyhow!(err)),
+                }
+            }
+
+            LuauExecutionCommands::GetLogs {
+                universe_id,
+                place_id,
+                version_id,
+                session_id,
+                task_id,
+                max_page_size,
+                page_token,
+                view,
+                pretty,
+                api_key,
+            } => {
+                let client = Client::new(&api_key);
+
+                let luau = client.luau(UniverseId(universe_id), PlaceId(place_id), version_id);
+
+                let res = luau
+                    .get_logs(
+                        session_id,
+                        task_id,
+                        view.unwrap_or(LuauExecutionTaskLogView::Flat),
+                        max_page_size,
+                        page_token,
+                    )
+                    .await;
+                match res {
+                    Ok(data) => {
+                        let r = if pretty {
+                            serde_json::to_string_pretty(&data)?
+                        } else {
+                            serde_json::to_string(&data)?
+                        };
+                        Ok(Some(r))
+                    }
+                    Err(err) => Err(anyhow::anyhow!(err)),
+                }
+            }
+        }
+    }
+}
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
index 1c06e27..2ecaab5 100644
--- a/src/cli/mod.rs
+++ b/src/cli/mod.rs
@@ -2,6 +2,7 @@ mod assets_cli;
 mod datastore_cli;
 mod experience_cli;
 mod group_cli;
+mod luau_execution_cli;
 mod messaging_cli;
 mod notification_cli;
 mod ordered_datastore_cli;
@@ -11,6 +12,7 @@ mod universe_cli;
 mod user_cli;
 
 use clap::{Parser, Subcommand};
+use luau_execution_cli::Luau;
 use universe_cli::Universe;
 use user_cli::User;
 
@@ -47,6 +49,8 @@ pub enum Command {
     /// Access the Roblox Group API
     Group(Group),
 
+    Luau(Luau),
+
     /// Access the Roblox Subscription API
     Subscription(Subscription),
 
@@ -72,6 +76,7 @@ impl Cli {
             Command::Datastore(command) => command.run().await,
             Command::OrderedDatastore(command) => command.run().await,
             Command::Group(command) => command.run().await,
+            Command::Luau(command) => command.run().await,
             Command::Subscription(command) => command.run().await,
             Command::Notification(command) => command.run().await,
             Command::Place(command) => command.run().await,
diff --git a/src/rbx/types.rs b/src/rbx/types.rs
index aee3e99..81eea6c 100644
--- a/src/rbx/types.rs
+++ b/src/rbx/types.rs
@@ -1,9 +1,11 @@
+use serde::{Deserialize, Serialize};
+
 /// Represents the UniverseId of a Roblox experience.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct UniverseId(pub u64);
 
 /// Represents the PlaceId of a specific place within a Roblox experience.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct PlaceId(pub u64);
 
 // Number of items to return.
diff --git a/src/rbx/v2/luau_execution.rs b/src/rbx/v2/luau_execution.rs
new file mode 100644
index 0000000..eb29e01
--- /dev/null
+++ b/src/rbx/v2/luau_execution.rs
@@ -0,0 +1,272 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::rbx::{
+    error::Error,
+    types::{PlaceId, UniverseId},
+    util::QueryString,
+};
+
+use super::http_err::handle_http_err;
+
+#[derive(Debug)]
+pub struct CreateLuauExecutionTaskParams {
+    pub api_key: String,
+    pub universe_id: UniverseId,
+    pub place_id: PlaceId,
+    pub version_id: Option<String>,
+    pub script: String,
+    pub timeout: Option<String>,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct NewLuauExecutionSessionTask {
+    pub path: String,
+    pub user: String,
+    pub state: LuauExecutionState,
+    pub script: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct GetLuauExecutionSessionTaskParams {
+    pub api_key: String,
+    pub universe_id: UniverseId,
+    pub place_id: PlaceId,
+    pub version_id: Option<String>,
+    pub session_id: String,
+    pub task_id: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct GetLuauExecutionSessionTaskLogsParams {
+    pub api_key: String,
+    pub universe_id: UniverseId,
+    pub place_id: PlaceId,
+    pub version_id: Option<String>,
+    pub session_id: String,
+    pub task_id: String,
+    pub max_page_size: Option<u32>,
+    pub page_token: Option<String>,
+    pub view: LuauExecutionTaskLogView,
+}
+
+#[derive(Debug, Clone, Copy, clap::ValueEnum, Deserialize, Serialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum LuauExecutionTaskLogView {
+    Flat,
+    Structured,
+}
+
+impl std::fmt::Display for LuauExecutionTaskLogView {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Flat => "FLAT",
+                Self::Structured => "STRUCTURED",
+            }
+        )
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct LuauExecutionSessionTaskLogPage {
+    pub luau_execution_session_task_logs: Vec<LuauExecutionSessionTaskLog>,
+    pub next_page_token: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct LuauExecutionSessionTaskLog {
+    pub path: String,
+    pub messages: Vec<String>,
+    pub structured_messages: Vec<StructuredMessage>,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct StructuredMessage {
+    pub message: String,
+    pub create_time: String,
+    pub message_type: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct LuauExecutionSessionTask {
+    pub path: String,
+    pub create_time: String,
+    pub update_time: String,
+    pub user: String,
+    pub state: LuauExecutionState,
+    pub output: LuauExecutionOutput,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct LuauExecutionOutput {
+    pub results: Vec<Value>,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum LuauExecutionState {
+    StateUnspecified,
+    Queued,
+    Processing,
+    Cancelled,
+    Complete,
+    Failed,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct LuauExecutionInput {
+    pub script: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<String>,
+}
+
+pub async fn create_luau_execution_task(
+    params: &CreateLuauExecutionTaskParams,
+) -> Result<NewLuauExecutionSessionTask, Error> {
+    let client = reqwest::Client::new();
+
+    let url = if let Some(version_id) = &params.version_id {
+        format!(
+			"https://apis.roblox.com/cloud/v2/universes/{universeId}/places/{placeId}/versions/{versionId}/luau-execution-session-tasks",
+			universeId = &params.universe_id,
+			placeId = &params.place_id,
+			versionId = version_id,
+		)
+    } else {
+        format!(
+			"https://apis.roblox.com/cloud/v2/universes/{universeId}/places/{placeId}/luau-execution-session-tasks",
+			universeId = &params.universe_id,
+			placeId = &params.place_id,
+		)
+    };
+
+    let input = LuauExecutionInput {
+        script: params.script.clone(),
+        timeout: params.timeout.clone(),
+    };
+
+    let req_body = serde_json::to_string(&input)?;
+
+    let res = client
+        .post(url)
+        .header("x-api-key", &params.api_key)
+        .header("Content-Type", "application/json")
+        .body(req_body)
+        .send()
+        .await?;
+
+    let status = res.status();
+
+    if !status.is_success() {
+        let code = status.as_u16();
+        return handle_http_err(code);
+    }
+
+    let body = res.json::<NewLuauExecutionSessionTask>().await?;
+    Ok(body)
+}
+
+pub async fn get_luau_execution_task(
+    params: &GetLuauExecutionSessionTaskParams,
+) -> Result<LuauExecutionSessionTask, Error> {
+    let client = reqwest::Client::new();
+
+    let url = if let Some(version_id) = &params.version_id {
+        format!(
+			"https://apis.roblox.com/cloud/v2/universes/{universeId}/places/{placeId}/versions/{versionId}/luau-execution-sessions/{sessionId}/tasks/{taskId}",
+			universeId = &params.universe_id,
+			placeId = &params.place_id,
+			versionId = version_id,
+			sessionId = &params.session_id,
+			taskId = &params.task_id,
+		)
+    } else {
+        format!(
+			"https://apis.roblox.com/cloud/v2/universes/{universeId}/places/{placeId}/luau-execution-sessions/{sessionId}/tasks/{taskId}",
+			universeId = &params.universe_id,
+			placeId = &params.place_id,
+			sessionId = &params.session_id,
+			taskId = &params.task_id,
+		)
+    };
+
+    let res = client
+        .get(url)
+        .header("x-api-key", &params.api_key)
+        .send()
+        .await?;
+
+    let status = res.status();
+
+    if !status.is_success() {
+        let code = status.as_u16();
+        return handle_http_err(code);
+    }
+
+    let body = res.json::<LuauExecutionSessionTask>().await?;
+    Ok(body)
+}
+
+pub async fn get_luau_execution_task_logs(
+    params: &GetLuauExecutionSessionTaskLogsParams,
+) -> Result<LuauExecutionSessionTaskLogPage, Error> {
+    let client = reqwest::Client::new();
+
+    let url = if let Some(version_id) = &params.version_id {
+        format!(
+			"https://apis.roblox.com/cloud/v2/universes/{universeId}/places/{placeId}/versions/{versionId}/luau-execution-sessions/{sessionId}/tasks/{taskId}/logs",
+			universeId = &params.universe_id,
+			placeId = &params.place_id,
+			versionId = version_id,
+			sessionId = &params.session_id,
+			taskId = &params.task_id,
+		)
+    } else {
+        format!(
+			"https://apis.roblox.com/cloud/v2/universes/{universeId}/places/{placeId}/luau-execution-sessions/{sessionId}/tasks/{taskId}/logs",
+			universeId = &params.universe_id,
+			placeId = &params.place_id,
+			sessionId = &params.session_id,
+			taskId = &params.task_id,
+		)
+    };
+
+    let mut query: QueryString = vec![("view", params.view.to_string())];
+    if let Some(max_page_size) = params.max_page_size {
+        query.push(("maxPageSize", format!("{max_page_size}")));
+    }
+    if let Some(page_token) = &params.page_token {
+        query.push(("pageToken", page_token.clone()));
+    }
+
+    let res = client
+        .get(url)
+        .header("x-api-key", &params.api_key)
+        .query(&query)
+        .send()
+        .await?;
+
+    println!("URL SENT: {}", res.url());
+
+    let status = res.status();
+
+    if !status.is_success() {
+        let code = status.as_u16();
+        return handle_http_err(code);
+    }
+
+    let body = res.json::<LuauExecutionSessionTaskLogPage>().await?;
+    Ok(body)
+}
diff --git a/src/rbx/v2/mod.rs b/src/rbx/v2/mod.rs
index 6c5d4d3..4ace408 100644
--- a/src/rbx/v2/mod.rs
+++ b/src/rbx/v2/mod.rs
@@ -2,6 +2,11 @@
 //!
 //! Most usage should go through the `Client` struct.
 
+use luau_execution::{
+    CreateLuauExecutionTaskParams, GetLuauExecutionSessionTaskLogsParams,
+    GetLuauExecutionSessionTaskParams, LuauExecutionSessionTask, LuauExecutionSessionTaskLogPage,
+    LuauExecutionTaskLogView, NewLuauExecutionSessionTask,
+};
 use place::{GetPlaceParams, PlaceInfo, UpdatePlaceInfo, UpdatePlaceParams};
 use universe::{
     GetUniverseParams, RestartUniverseServersParams, UniverseInfo, UpdateUniverseInfo,
@@ -23,6 +28,7 @@ use self::{
 };
 pub mod group;
 pub(crate) mod http_err;
+pub mod luau_execution;
 pub mod notification;
 pub mod place;
 pub mod subscription;
@@ -51,6 +57,13 @@ pub struct GroupClient {
     pub group_id: GroupId,
 }
 
+pub struct LuauExecutionClient {
+    pub api_key: String,
+    pub universe_id: UniverseId,
+    pub place_id: PlaceId,
+    pub version_id: Option<String>,
+}
+
 pub struct SubscriptionClient {
     pub api_key: String,
 }
@@ -123,6 +136,62 @@ impl GroupClient {
     }
 }
 
+impl LuauExecutionClient {
+    pub async fn create_task(
+        &self,
+        script: String,
+        timeout: Option<String>,
+    ) -> Result<NewLuauExecutionSessionTask, Error> {
+        luau_execution::create_luau_execution_task(&CreateLuauExecutionTaskParams {
+            api_key: self.api_key.clone(),
+            universe_id: self.universe_id,
+            place_id: self.place_id,
+            version_id: self.version_id.clone(),
+            script,
+            timeout,
+        })
+        .await
+    }
+
+    pub async fn get_task(
+        &self,
+        session_id: String,
+        task_id: String,
+    ) -> Result<LuauExecutionSessionTask, Error> {
+        luau_execution::get_luau_execution_task(&GetLuauExecutionSessionTaskParams {
+            api_key: self.api_key.clone(),
+            universe_id: self.universe_id,
+            place_id: self.place_id,
+            version_id: self.version_id.clone(),
+            session_id,
+            task_id,
+        })
+        .await
+    }
+
+    pub async fn get_logs(
+        &self,
+        session_id: String,
+        task_id: String,
+        view: LuauExecutionTaskLogView,
+        max_page_size: Option<u32>,
+        page_token: Option<String>,
+    ) -> Result<LuauExecutionSessionTaskLogPage, Error> {
+        luau_execution::get_luau_execution_task_logs(&GetLuauExecutionSessionTaskLogsParams {
+            api_key: self.api_key.clone(),
+            universe_id: self.universe_id,
+            place_id: self.place_id,
+            version_id: self.version_id.clone(),
+            session_id,
+            task_id,
+            view,
+            max_page_size,
+            page_token,
+        })
+        .await
+    }
+}
+
 impl SubscriptionClient {
     pub async fn get(
         &self,
@@ -256,6 +325,20 @@ impl Client {
         }
     }
 
+    pub fn luau(
+        &self,
+        universe_id: UniverseId,
+        place_id: PlaceId,
+        version_id: Option<String>,
+    ) -> LuauExecutionClient {
+        LuauExecutionClient {
+            api_key: self.api_key.clone(),
+            universe_id,
+            place_id,
+            version_id,
+        }
+    }
+
     pub fn subscription(&self) -> SubscriptionClient {
         SubscriptionClient {
             api_key: self.api_key.clone(),