Build a Discount Function that has network access

In this tutorial, you'll build a Shopify Function that validates discount codes against an external system then applies valid discounts to a buyer's cart. Using network access, you'll configure HTTP requests to fetch data from external services and provide that data as input to your run Function. To learn more, see network access for Shopify Functions.

Shopify for enterprise

Network access for Shopify Functions is limited to Shopify for enterprise plans. For more information, contact our enterprise sales team.

Anchor to What you'll learnWhat you'll learn

In this tutorial, you'll learn how to do the following tasks:

Add a network request to your Function.
Respond to the network request with a mock HTTP server.
Create a tunnel using a service like Ngrok to expose your mock HTTP server to the internet.
Deploy your Function to Shopify.
Review logs for your Function.
Test your Function in checkout.

Requirements

Create a Partner account

Create a development store

Scaffold an app with a Discount Function

For example, follow the Build a Discount Function tutorial, or build your own app and Discount Function using the Discount API.

Project

Extension:

View on GitHub

Using the app you already have, or the one you created by completing the Build a Discount Function tutorial, you can add network access to your Function.

Anchor to Update your Function to access the networkUpdate your Function to access the network

In this step, you'll update your Function to access the network and use the fetchResult in the run target's input query.

Anchor to Add network access targetsAdd network access targets

To access a network from your Shopify Function, add the cart.lines.discounts.generate.fetch and cart.delivery-options.discounts.generate.fetch targets to your shopify.extension.toml file.

The [[extensions.targeting]] sections define the Function targets. Each section includes a target, input_query, and export property.

The target property defines where the Function is applied. There are two network access targets:

cart.lines.discounts.generate.fetch: This target runs before the cart.lines.discounts.generate.run target.
cart.delivery-options.discounts.generate.fetch: This target runs before the cart.delivery-options.discounts.generate.run target.

The input_query property is the path to the Function's input query file. The input query file defines the Function's input parameters.

The export property specifies the entry point for your Function's discount calculation logic.

extensions/discount-function/shopify.extension.toml

api_version = "2025-04"

[[extensions]]

name = "t:name"

handle = "discount-function-rs"

type = "function"

description = "t:description"

[[extensions.targeting]]

target = "cart.lines.discounts.generate.run"

input_query = "src/cart_lines_discounts_generate_run.graphql"

export = "cart_lines_discounts_generate_run"

[[extensions.targeting]]

target = "cart.delivery-options.discounts.generate.run"

input_query = "src/cart_delivery_options_discounts_generate_run.graphql"

export = "cart_delivery_options_discounts_generate_run"

[[extensions.targeting]]

target = "cart.lines.discounts.generate.fetch"

input_query = "src/cart_lines_discounts_generate_fetch.graphql"

export = "cart_lines_discounts_generate_fetch"

[[extensions.targeting]]

target = "cart.delivery-options.discounts.generate.fetch"

input_query = "src/cart_delivery_options_discounts_generate_fetch.graphql"

export = "cart_delivery_options_discounts_generate_fetch"

[extensions.build]

command = "cargo build --target=wasm32-wasip1 --release"

path = "target/wasm32-wasip1/release/discount-function-rs.wasm"

watch = [ "src/**/*.rs" ]

Anchor to Query the ,[object Object], for the cart fetch targetQuery the `enteredDiscountCodes` for the cart fetch target

Create a cart_lines_discounts_generate_fetch.graphql input query file that provides data to your Function. This allows you to conditionally build an HTTP request that is then executed by Shopify. For example, you can query enteredDiscountCodes, which allow you to perform validations against your external service.

Anchor to Query the ,[object Object], for the delivery fetch targetQuery the `enteredDiscountCodes` for the delivery fetch target

Create a cart_delivery_options_discounts_generate_fetch.graphql input query file that provides data to your Function. This allows you to conditionally build an HTTP request that is then executed by Shopify. For example, you can query enteredDiscountCodes, which allow you to perform validations against your external service.

Anchor to Query the ,[object Object], for the cart run targetQuery the `fetchResult` for the cart run target

Update the cart_lines_discounts_generate_run.graphql file. The fetchResult from the fetch request will be the input to your cart.lines.discounts.generate.run target. Refer to Discount API for more information about the input data available to your Function.

Anchor to Query the ,[object Object], for the delivery run targetQuery the `fetchResult` for the delivery run target

Update the cart_delivery_options_discounts_generate_run.graphql file. The fetchResult from the fetch request will be the input to your cart.delivery-options.discounts.generate.run Function. Refer to Discount API for more information about the input data available to your Function.

Anchor to Add an export for the cart fetch targetAdd an export for the cart fetch target

Shopify uses the cart.lines.discounts.generate.fetch target to build an HTTP request, which it executes and provides to your run target as input.

extensions/discount-function/src/cart_lines_discounts_generate_fetch.rs

use super::schema;

use shopify_function;

use shopify_function::prelude::*;

use std::collections::BTreeMap;

#[shopify_function]

fn cart_lines_discounts_generate_fetch(

input: schema::cart_lines_discounts_generate_fetch::Input,

) -> shopify_function::Result<schema::CartLinesDiscountsGenerateFetchResult> {

let entered_discount_codes = &input.entered_discount_codes();

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(

entered_discount_codes

.iter()

.map(|s| JsonValue::String(s.clone()))

.collect(),

)]));

let request = schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

json_body: Some(json_body.clone()),

body: None,

};

Ok(schema::CartLinesDiscountsGenerateFetchResult {

request: Some(request),

})

}

#[cfg(test)]

mod tests {

use super::*;

use serde_json::json;

use shopify_function::run_function_with_input;

#[test]

    fn adds_entered_discount_codes_to_json_body_for_cart() -> shopify_function::Result<()> {

let input = json!({

"enteredDiscountCodes": [],

"cart": {

"lines": []

}

})

.to_string();

        let result = run_function_with_input(cart_lines_discounts_generate_fetch, &input)?;

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(vec![]),

)]));

let expected = schema::CartLinesDiscountsGenerateFetchResult {

request: Some(schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

json_body: Some(json_body),

body: None,

}),

};

assert_eq!(result, expected);

Ok(())

}

Anchor to Add an export for the delivery fetch targetAdd an export for the delivery fetch target

Shopify uses the cart.delivery-options.discounts.generate.fetch target to build an HTTP request, which it executes and provides to your run target as input.

extensions/discount-function/src/cart_delivery_options_discounts_generate_fetch.rs

use super::schema;

use shopify_function;

use shopify_function::prelude::*;

use std::collections::BTreeMap;

#[shopify_function]

fn cart_delivery_options_discounts_generate_fetch(

input: schema::cart_delivery_options_discounts_generate_fetch::Input,

) -> shopify_function::Result<schema::CartDeliveryOptionsDiscountsGenerateFetchResult> {

let entered_discount_codes = &input.entered_discount_codes();

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(

entered_discount_codes

.iter()

.map(|s| JsonValue::String(s.clone()))

.collect(),

)]));

let request = schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

body: None,

json_body: Some(json_body.clone()),

};

Ok(schema::CartDeliveryOptionsDiscountsGenerateFetchResult {

request: Some(request),

})

}

#[cfg(test)]

mod tests {

use super::*;

use serde_json::json;

use shopify_function::run_function_with_input;

#[test]

fn adds_entered_discount_codes_to_json_body_for_delivery() -> shopify_function::Result<()> {

let input = json!({

"enteredDiscountCodes": [],

"cart": {

"lines": []

}

})

.to_string();

let result =

run_function_with_input(cart_delivery_options_discounts_generate_fetch, &input)?;

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(vec![]),

)]));

let expected = schema::CartDeliveryOptionsDiscountsGenerateFetchResult {

request: Some(schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

json_body: Some(json_body),

body: None,

}),

};

assert_eq!(result, expected);

Ok(())

}

Anchor to Parse the result from the network call in the cart run targetParse the result from the network call in the cart run target

Update the cart.lines.discounts.generate.run target to handle the response from the network call. This target parses the fetchResult from the network call and uses it to apply a discount to the cart lines.

extensions/discount-function/src/cart_lines_discounts_generate_run.rs

use super::schema;

use shopify_function::prelude::*;

use shopify_function::Result;

#[derive(Deserialize)]

#[shopify_function(rename_all = "camelCase")]

pub struct OperationItem {

product_discounts_add: Option<schema::ProductDiscountsAddOperation>,

order_discounts_add: Option<schema::OrderDiscountsAddOperation>,

    entered_discount_codes_accept: Option<schema::EnteredDiscountCodesAcceptOperation>,

}

pub type JsonBody = Vec<OperationItem>;

#[shopify_function]

fn cart_lines_discounts_generate_run(

input: schema::cart_lines_discounts_generate_run::Input,

) -> Result<schema::CartLinesDiscountsGenerateRunResult> {

let fetch_result = input.fetch_result().ok_or("Missing fetch result")?;

let discount_classes = &input.discount().discount_classes();

// Check if relevant discount classes are set

    let has_order_discount_class = discount_classes.contains(&schema::DiscountClass::Order);

    let has_product_discount_class = discount_classes.contains(&schema::DiscountClass::Product);

// If no relevant discount class is set, return empty operations

if !has_order_discount_class && !has_product_discount_class {

return Ok(schema::CartLinesDiscountsGenerateRunResult { operations: vec![] });

}

// Use jsonBody which is the only available property

let operation_items = fetch_result

.json_body()

.ok_or("Missing json_body in response")?;

// Convert the response into operations

let mut operations = Vec::new();

Anchor to Parse the result from the network call in the delivery run targetParse the result from the network call in the delivery run target

Update the cart.delivery-options.discounts.generate.run target to handle the response from the network call. This target parses the fetchResult from the network call and uses it to apply a discount to the delivery options.

extensions/discount-function/src/cart_delivery_options_discounts_generate_run.rs

use super::schema;

use shopify_function::prelude::*;

use shopify_function::Result;

#[derive(Deserialize)]

#[shopify_function(rename_all = "camelCase")]

pub struct OperationItem {

delivery_discounts_add: Option<schema::DeliveryDiscountsAddOperation>,

    entered_discount_codes_accept: Option<schema::EnteredDiscountCodesAcceptOperation>,

}

pub type JsonBody = Vec<OperationItem>;

#[shopify_function]

fn cart_delivery_options_discounts_generate_run(

input: schema::cart_delivery_options_discounts_generate_run::Input,

) -> Result<schema::CartDeliveryOptionsDiscountsGenerateRunResult> {

let fetch_result = input.fetch_result().ok_or("Missing fetch result")?;

let discount_classes = &input.discount().discount_classes();

// Check if shipping discount class is set

    let has_shipping_discount_class = discount_classes.contains(&schema::DiscountClass::Shipping);

// If shipping discount class is not set, return empty operations

if !has_shipping_discount_class {

        return Ok(schema::CartDeliveryOptionsDiscountsGenerateRunResult { operations: vec![] });

}

// Use jsonBody which is the only available property

let operation_items = fetch_result

.json_body()

.ok_or("Missing json_body in response")?;

// Convert the response into operations

let mut operations = Vec::new();

// Process each operation item

for item in operation_items {

// Always include discount code operations

if let Some(validations) = &item.entered_discount_codes_accept {

operations.push(schema::DeliveryOperation::EnteredDiscountCodesAccept(

validations.clone(),

));

}

// Include delivery discounts (shipping discount class is already verified)

if let Some(delivery_discounts_add_operation) = &item.delivery_discounts_add {

operations.push(schema::DeliveryOperation::DeliveryDiscountsAdd(

delivery_discounts_add_operation.clone(),

));

}

// Ignore cart/order discounts for delivery operations

}

Ok(schema::CartDeliveryOptionsDiscountsGenerateRunResult { operations })

}

Anchor to Export the fetch request targets in your main fileExport the fetch request targets in your main file

Add the cart_lines_discounts_generate_fetch and cart_delivery_options_discounts_generate_fetch exports to the main.rs file. The main.rs file is the entry point for your Shopify Function.

extensions/discount-function/src/main.rs

use std::process;

pub mod cart_delivery_options_discounts_generate_run;

pub mod cart_lines_discounts_generate_run;

pub mod cart_delivery_options_discounts_generate_fetch;

pub mod cart_lines_discounts_generate_fetch;

use shopify_function::typegen;

#[typegen("schema.graphql")]

pub mod schema {

#[query("src/cart_delivery_options_discounts_generate_fetch.graphql")]

pub mod cart_delivery_options_discounts_generate_fetch {}

#[query("src/cart_lines_discounts_generate_fetch.graphql")]

pub mod cart_lines_discounts_generate_fetch {}

#[query(

"src/cart_delivery_options_discounts_generate_run.graphql",

custom_scalar_overrides = {

            "Input.fetchResult.jsonBody" => super::cart_delivery_options_discounts_generate_run::JsonBody

}

)]

pub mod cart_delivery_options_discounts_generate_run {}

#[query (

"src/cart_lines_discounts_generate_run.graphql",

custom_scalar_overrides = {

            "Input.fetchResult.jsonBody" => super::cart_lines_discounts_generate_run::JsonBody

}

)]

pub mod cart_lines_discounts_generate_run {}

}

fn main() {

eprintln!("Please invoke a named export.");

process::exit(1);

}

Anchor to Ensure the name of the function package, matches the handle of your FunctionEnsure the name of the function package, matches the handle of your Function

In the Cargo.toml file, ensure the name of the function package matches the handle of your Function. The handle is the name you provided when you created your Function and it can be found in the shopify.extension.toml file.

Anchor to Re-generate the schemaRe-generate the schema

You must regenerate the new Discount API schema to support the new properties you added to your Function Input and Output.

Terminal

shopify app function schema

Anchor to Set up a web service to respond to your Function's network requestsSet up a web service to respond to your Function's network requests

To provide network access to your Function, set up an external service that can respond to the HTTP requests that Shopify will make on behalf of your Function.

When your Shopify Function runs, it cannot make network requests directly. Instead, Shopify makes the requests on behalf of your Function to URLs you specify. In a production environment, this would typically be an API endpoint within your existing infrastructure. For this tutorial, we'll create a simple mock HTTP server.

Caution

When you test this server in development, there is no URL validation against the value found in the JSON web token. Since the URL of your tunnel can change often, you can ignore validating the URL. In production, you should validate the URL to ensure it matches the value found in the JSON web token.

Anchor to Setup a mock HTTP server with RemixSetup a mock HTTP server with Remix

Info

This is a separate app from your Shopify App. Create it in a new folder outside your Shopify app.

Create a new Remix app from the Remix template:

In a separate folder from your Shopify app, run the following command to create a new Remix app. This will create a new directory called mock-http-server with the Remix app inside it.

Terminal

npx create-remix@latest mock-http-server --template remix-run/remix/templates/remix-javascript

Navigate to the mock HTTP server directory

Terminal

cd mock-http-server

Install the jsonwebtoken package:

Terminal

npm i jsonwebtoken

Anchor to Create an API route in the routes directoryCreate an API route in the routes directory

Create a file named api.js in the /routes directory of the mock-http-server app. The code authenticates the request by verifying the JWT, and then executes the the associated business logic, which returns discount operations.

Anchor to Review the response from the mock HTTP serverReview the response from the mock HTTP server

The mock HTTP server responds to your Function's HTTP requests, which are made by Shopify with an object similar to this sample code. This object can then be queried as the fetchResult for the input of your cart.lines.discounts.generate.run and cart.delivery-options.discounts.generate.run targets.

app/routes/api.js

import { subtle } from "crypto";

import { TextEncoder } from "util";

import { json } from "@remix-run/node";

import jwt from "jsonwebtoken";

const selectionStrategy = {

All: "ALL",

First: "FIRST",

Maximum: "MAXIMUM",

};

const PRODUCT_DISCOUNT_CODE = "10OFFPRODUCT";

const ORDER_DISCOUNT_CODE = "20OFFORDER";

const SHIPPING_DISCOUNT_CODE = "FREESHIPPING";

export const action = async ({ request }) => {

if (request.method.toUpperCase() !== "POST") {

return json({

error: "Invalid request method. Only POST requests are allowed.",

});

}

let body;

try {

body = await authenticate(request);

} catch (err) {

return json({ error: err.message });

}

return handle(body);

};

const authenticate = async (request) => {

const requestJwtHeader = request.headers.get("x-shopify-request-jwt");

const requestIdHeader = request.headers.get("x-shopify-request-id");

Anchor to Create an environment file in the root of your appCreate an environment file in the root of your app

This file contains the environment variables for your application:

APP_CLIENT_SECRET: Find this on your App's overview page in the Partner Dashboard
JWT_SHOP_ID: Find this in the URL of your Store's overview page in the Partner Dashboard

Anchor to Run your mock HTTP server locallyRun your mock HTTP server locally

Run your mock HTTP server locally using the following command:

Terminal

npm run dev

Anchor to Use a service like Ngrok to expose your local server to the internet.Use a service like Ngrok to expose your local server to the internet.

To setup Ngrok, follow these steps. Then you can create a tunnel to your local server.

In a separate terminal, start the Ngrok tunnel:

Terminal

ngrok http 5173

Anchor to Update the ,[object Object], in your cart fetch targetUpdate the `url` in your cart fetch target

In your cart_lines_discounts_generate_fetch.rs file, replace the url with that of the Ngrok tunnel you created in the previous step.

Terminal

https://<ngrok-url>/api

extensions/discount-function/src/cart_lines_discounts_generate_fetch.rs

use super::schema;

use shopify_function;

use shopify_function::prelude::*;

use std::collections::BTreeMap;

#[shopify_function]

fn cart_lines_discounts_generate_fetch(

input: schema::cart_lines_discounts_generate_fetch::Input,

) -> shopify_function::Result<schema::CartLinesDiscountsGenerateFetchResult> {

let entered_discount_codes = &input.entered_discount_codes();

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(

entered_discount_codes

.iter()

.map(|s| JsonValue::String(s.clone()))

.collect(),

)]));

let request = schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

json_body: Some(json_body.clone()),

body: None,

};

Ok(schema::CartLinesDiscountsGenerateFetchResult {

request: Some(request),

})

}

#[cfg(test)]

mod tests {

use super::*;

use serde_json::json;

use shopify_function::run_function_with_input;

#[test]

fn adds_entered_discount_codes_to_json_body_for_cart() -> shopify_function::Result<()> {

let input = json!({

"enteredDiscountCodes": [],

"cart": {

"lines": []

}

})

.to_string();

let result = run_function_with_input(cart_lines_discounts_generate_fetch, &input)?;

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(vec![]),

)]));

let expected = schema::CartLinesDiscountsGenerateFetchResult {

request: Some(schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

json_body: Some(json_body),

body: None,

}),

};

assert_eq!(result, expected);

Ok(())

}

Anchor to Update the ,[object Object], in your delivery fetch targetUpdate the `url` in your delivery fetch target

In your cart_delivery_options_discounts_generate_fetch.rs file, replace the url with that of the Ngrok tunnel you created in the previous step.

Terminal

https://<ngrok-url>/api

extensions/discount-function/src/cart_delivery_options_discounts_generate_fetch.rs

use super::schema;

use shopify_function;

use shopify_function::prelude::*;

use std::collections::BTreeMap;

#[shopify_function]

fn cart_delivery_options_discounts_generate_fetch(

input: schema::cart_delivery_options_discounts_generate_fetch::Input,

) -> shopify_function::Result<schema::CartDeliveryOptionsDiscountsGenerateFetchResult> {

let entered_discount_codes = &input.entered_discount_codes();

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(

entered_discount_codes

.iter()

.map(|s| JsonValue::String(s.clone()))

.collect(),

)]));

let request = schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

body: None,

json_body: Some(json_body.clone()),

};

Ok(schema::CartDeliveryOptionsDiscountsGenerateFetchResult {

request: Some(request),

})

}

#[cfg(test)]

mod tests {

use super::*;

use serde_json::json;

use shopify_function::run_function_with_input;

#[test]

fn adds_entered_discount_codes_to_json_body_for_delivery() -> shopify_function::Result<()> {

let input = json!({

"enteredDiscountCodes": [],

"cart": {

"lines": []

}

})

.to_string();

let result =

run_function_with_input(cart_delivery_options_discounts_generate_fetch, &input)?;

let json_body = JsonValue::Object(BTreeMap::from([(

"enteredDiscountCodes".to_string(),

JsonValue::Array(vec![]),

)]));

let expected = schema::CartDeliveryOptionsDiscountsGenerateFetchResult {

request: Some(schema::HttpRequest {

headers: vec![

schema::HttpRequestHeader {

value: "application/json".to_string(),

schema::HttpRequestHeader {

value: "application/json".to_string(),

method: schema::HttpRequestMethod::Post,

policy: schema::HttpRequestPolicy {

read_timeout_ms: 2000,

url: "<external-server-url>/api".to_string(),

json_body: Some(json_body),

body: None,

}),

};

assert_eq!(result, expected);

Ok(())

}

Anchor to Add your tunnel URL to the list of allowed hosts in your mock-http-server's Vite configAdd your tunnel URL to the list of allowed hosts in your mock-http-server's Vite config

To allow your tunnel to proxy traffic to localhost, add the tunnel URL to the list of approved hosts in your Vite config. This is necessary because Vite uses a proxy to forward requests to your local server. Don't include the https:// or http:// prefix in the URL.

vite.config.js

import { vitePlugin as remix } from "@remix-run/dev";

import { defineConfig } from "vite";

export default defineConfig({

plugins: [

remix({

future: {

v3_fetcherPersist: true,

v3_relativeSplatPath: true,

v3_throwAbortReason: true,

v3_singleFetch: true,

v3_lazyRouteDiscovery: true,

}),

server: {

allowedHosts: ["<ngrok-url>"],

});

Anchor to Deploy your updated functionDeploy your updated function

Deploy your updated configuration to Shopify:

Terminal
shopify app deploy
Restart your app development server:

Terminal
shopify app dev
Open or reinstall your app using the URL provided by Shopify CLI. To preview your extensions, press p in the terminal window where you started your app.
Accept the new access scope permissions in your store.

Anchor to Test the discount with network accessTest the discount with network access

Anchor to Trigger the discount on your development storeTrigger the discount on your development store

From your Shopify admin, go to Discounts. You should now see the Cart line, order and shipping that you created.
Open your development store and build a cart with a single item in it.
Add 10OFFPRODUCT, 20OFFORDER, and FREESHIPPING codes in the Discount codes or gift card field.
After you navigate to the checkout page, shipping discounts display on the checkout page after you provide your shipping address.

Anchor to Review the Function executionReview the Function execution

In the terminal where shopify app dev is running, review your Function executions.

When testing Functions on development stores, the dev output shows Function executions, debug logs you've added, and a link to a local file containing full execution details.
In a new terminal window, use the Shopify CLI command app function replay to replay a Function execution locally. This lets you debug your Function without triggering it again on Shopify.

Terminal
shopify app function replay
Select the Function execution from the top of the list. Press q to quit when you are finished debugging.

extensions/discount-function/shopify.extension.toml

api_version = "2025-04"

[[extensions]]

name = "t:name"

handle = "discount-function-rs"

type = "function"

description = "t:description"

[[extensions.targeting]]

target = "cart.lines.discounts.generate.run"

input_query = "src/cart_lines_discounts_generate_run.graphql"

export = "cart_lines_discounts_generate_run"

[[extensions.targeting]]

target = "cart.delivery-options.discounts.generate.run"

input_query = "src/cart_delivery_options_discounts_generate_run.graphql"

export = "cart_delivery_options_discounts_generate_run"

[[extensions.targeting]]

target = "cart.lines.discounts.generate.fetch"

input_query = "src/cart_lines_discounts_generate_fetch.graphql"

export = "cart_lines_discounts_generate_fetch"

[[extensions.targeting]]

target = "cart.delivery-options.discounts.generate.fetch"

input_query = "src/cart_delivery_options_discounts_generate_fetch.graphql"

export = "cart_delivery_options_discounts_generate_fetch"

[extensions.build]

command = "cargo build --target=wasm32-wasip1 --release"

path = "target/wasm32-wasip1/release/discount-function-rs.wasm"

watch = [ "src/**/*.rs" ]

Anchor to Tutorial complete!Tutorial complete!

You've successfully created a Discount Function with network access. You can now use this Function to apply discounts that target cart lines, order subtotals, and shipping rates, while validating discount codes against an external system.

Anchor to Next StepsNext Steps

Build a UI extension to configure your discount Function

Add configuration to your discounts experience using metafields and build a user interface for your Function.

Build a Remix app to configure your discount Function

Add configuration to your discounts experience using metafields and build a user interface for your Function.

Review the UX guidelines

Review the UX guidelines to learn how to implement discounts in user interfaces.

Learn more about Shopify Functions

Learn more about how Shopify Functions work and the benefits of using Shopify Functions.

Build a Discount Function that has network access

Anchor to What you'll learnWhat you'll learn

Requirements

Project

Anchor to Update your Function to access the networkUpdate your Function to access the network

Anchor to Add network access targetsAdd network access targets

Anchor to Query the ,[object Object], for the cart fetch targetQuery the enteredDiscountCodes for the cart fetch target

Anchor to Query the ,[object Object], for the delivery fetch targetQuery the enteredDiscountCodes for the delivery fetch target

Anchor to Query the ,[object Object], for the cart run targetQuery the fetchResult for the cart run target

Anchor to Query the ,[object Object], for the delivery run targetQuery the fetchResult for the delivery run target

Anchor to Add an export for the cart fetch targetAdd an export for the cart fetch target

Anchor to Add an export for the delivery fetch targetAdd an export for the delivery fetch target

Anchor to Parse the result from the network call in the cart run targetParse the result from the network call in the cart run target

Anchor to Parse the result from the network call in the delivery run targetParse the result from the network call in the delivery run target

Anchor to Export the fetch request targets in your main fileExport the fetch request targets in your main file

Anchor to Ensure the name of the function package, matches the handle of your FunctionEnsure the name of the function package, matches the handle of your Function

Anchor to Re-generate the schemaRe-generate the schema

Anchor to Set up a web service to respond to your Function's network requestsSet up a web service to respond to your Function's network requests

Anchor to Setup a mock HTTP server with RemixSetup a mock HTTP server with Remix

Anchor to Create an API route in the routes directoryCreate an API route in the routes directory

Anchor to Review the response from the mock HTTP serverReview the response from the mock HTTP server

Anchor to Create an environment file in the root of your appCreate an environment file in the root of your app

Anchor to Run your mock HTTP server locallyRun your mock HTTP server locally

Anchor to Use a service like Ngrok to expose your local server to the internet.Use a service like Ngrok to expose your local server to the internet.

Anchor to Update the ,[object Object], in your cart fetch targetUpdate the url in your cart fetch target

Anchor to Update the ,[object Object], in your delivery fetch targetUpdate the url in your delivery fetch target

Anchor to Add your tunnel URL to the list of allowed hosts in your mock-http-server's Vite configAdd your tunnel URL to the list of allowed hosts in your mock-http-server's Vite config

Anchor to Deploy your updated functionDeploy your updated function

Anchor to Test the discount with network accessTest the discount with network access

Anchor to Trigger the discount on your development storeTrigger the discount on your development store

Anchor to Review the Function executionReview the Function execution

Anchor to Tutorial complete!Tutorial complete!

Anchor to Next StepsNext Steps

Anchor to Query the ,[object Object], for the cart fetch targetQuery the `enteredDiscountCodes` for the cart fetch target

Anchor to Query the ,[object Object], for the delivery fetch targetQuery the `enteredDiscountCodes` for the delivery fetch target

Anchor to Query the ,[object Object], for the cart run targetQuery the `fetchResult` for the cart run target

Anchor to Query the ,[object Object], for the delivery run targetQuery the `fetchResult` for the delivery run target

Anchor to Update the ,[object Object], in your cart fetch targetUpdate the `url` in your cart fetch target

Anchor to Update the ,[object Object], in your delivery fetch targetUpdate the `url` in your delivery fetch target