The Definitive Guide to Reliably Working with Shopify Webhooks over HTTPS Using Hookdeck

curl -X POST "https://api.hookdeck.com/2027-07-01/connections" \
  -H "Authorization: Bearer $HOOKDECK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Shopify-to-Production-App",
    "source": {
      "name": "shopify",
      "type": "SHOPIFY",
      "config": {
        "auth": {
          "webhook_secret_key": "your-app-client-secret"
        }
      }
    },
    "rules": [
      {
        "type": "retry",
        "count": 20,
        "interval": 300,
        "strategy": "exponential"
      },
      {
        "type": "deduplicate",
        "window": 300000,
        "include_fields": ["headers.x-shopify-event-id"]
      }
    ],
    "destination": {
      "name": "Production-App",
      "type": "HTTP",
      "config": {
        "url": "https://yourapp.com/webhooks/shopify"
      }
    }
  }'

const response = await fetch('https://api.hookdeck.com/2027-07-01/connections', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.HOOKDECK_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Shopify-to-Production-App',
    source: {
      name: 'shopify',
      type: 'SHOPIFY',
      config: {
        auth: {
          webhook_secret_key: 'your-app-client-secret'
        }
      }
    },
    destination: {
      name: 'Production-App',
      type: 'HTTP',
      config: {
        url: 'https://yourapp.com/webhooks/shopify'
      }
    },
    rules: [
      {
        type: 'retry',
        count: 20,
        interval: 300,
        strategy: 'exponential'
      },
      {
        type: 'deduplicate',
        window: 300000,
        include_fields: ['headers.x-shopify-event-id']
      }
    ]
  })
});

const connection = await response.json();
console.log('Connection created:', connection);

<?php
require_once 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->post('https://api.hookdeck.com/2027-07-01/connections', [
    'headers' => [
        'Authorization' => 'Bearer ' . $_ENV['HOOKDECK_API_KEY'],
        'Content-Type' => 'application/json'
    ],
    'json' => [
        'name' => 'Shopify-to-Production-App',
        'source' => [
            'name' => 'shopify',
            'type' => 'SHOPIFY',
            'config' => [
                'auth' => [
                    'webhook_secret_key' => 'your-app-client-secret'
                ]
            ]
        ],
        'destination' => [
            'name' => 'Production-App',
            'type' => 'HTTP',
            'config' => [
                'url' => 'https://yourapp.com/webhooks/shopify'
            ]
        ],
        'rules' => [
            [
                'type' => 'retry',
                'count' => 20,
                'interval' => 300,
                'strategy' => 'exponential'
            ],
            [
                'type' => 'deduplicate',
                'window' => 300000,
                'include_fields' => ['headers.x-shopify-event-id']
            ]
        ]
    ]
]);

$connection = json_decode($response->getBody(), true);
echo 'Connection created: ' . json_encode($connection) . "\n";
?>

require 'faraday'
require 'json'

# Create connection using Faraday
conn = Faraday.new(url: 'https://api.hookdeck.com') do |f|
  f.request :json
  f.response :json
  f.adapter Faraday.default_adapter
end

payload = {
  name: 'Shopify-to-Production-App',
  source: {
    name: 'shopify',
    type: 'SHOPIFY',
    config: {
      auth: {
        webhook_secret_key: 'your-app-client-secret'
      }
    }
  },
  destination: {
    name: 'Production-App',
    type: 'HTTP',
    config: {
      url: 'https://yourapp.com/webhooks/shopify'
    }
  },
  rules: [
    {
      type: 'retry',
      count: 20,
      interval: 300,
      strategy: 'exponential'
    },
    {
      type: 'deduplicate',
      window: 300000,
      include_fields: ['headers.x-shopify-event-id']
    }
  ]
}

response = conn.post('/2027-07-01/connections') do |req|
  req.headers['Authorization'] = "Bearer #{ENV['HOOKDECK_API_KEY']}"
  req.body = payload
end

connection = response.body
puts "Connection created: #{connection}"

import httpx
import asyncio
import os

async def create_connection():
    async with httpx.AsyncClient() as client:
        response = await client.post(
            'https://api.hookdeck.com/2027-07-01/connections',
            headers={
                'Authorization': f'Bearer {os.environ["HOOKDECK_API_KEY"]}',
                'Content-Type': 'application/json'
            },
            json={
                'name': 'Shopify-to-Production-App',
                'source': {
                    'name': 'shopify',
                    'type': 'SHOPIFY',
                    'config': {
                        'auth': {
                            'webhook_secret_key': 'your-app-client-secret'
                        }
                    }
                },
                'destination': {
                    'name': 'Production-App',
                    'type': 'HTTP',
                    'config': {
                        'url': 'https://yourapp.com/webhooks/shopify'
                    }
                },
                'rules': [
                    {
                        'type': 'retry',
                        'count': 20,
                        'interval': 300,
                        'strategy': 'exponential'
                    },
                    {
                        'type': 'deduplicate',
                        'window': 300000,
                        'include_fields': ['headers.x-shopify-event-id']
                    }
                ]
            },
            timeout=30.0
        )
        response.raise_for_status()
        
        connection = response.json()
        print('Connection created:', connection)
        return connection

# Usage
asyncio.run(create_connection())

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class HookdeckConnectionCreator {
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
    
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    public static void createConnection() throws Exception {
        // Build JSON payload
        ObjectNode payload = objectMapper.createObjectNode();
        payload.put("name", "Shopify-to-Production-App");
        
        ObjectNode source = objectMapper.createObjectNode();
        source.put("name", "shopify");
        source.put("type", "SHOPIFY");
        
        ObjectNode sourceConfig = objectMapper.createObjectNode();
        ObjectNode auth = objectMapper.createObjectNode();
        auth.put("webhook_secret_key", "your-app-client-secret");
        sourceConfig.set("auth", auth);
        source.set("config", sourceConfig);
        payload.set("source", source);
        
        ObjectNode destination = objectMapper.createObjectNode();
        destination.put("name", "Production-App");
        ObjectNode destConfig = objectMapper.createObjectNode();
        destConfig.put("type", "HTTP");
        destConfig.put("url", "https://yourapp.com/webhooks/shopify");
        destination.set("config", destConfig);
        payload.set("destination", destination);
        
        ArrayNode rules = objectMapper.createArrayNode();
        
        ObjectNode retryRule = objectMapper.createObjectNode();
        retryRule.put("type", "retry");
        retryRule.put("count", 20);
        retryRule.put("interval", 300);
        retryRule.put("strategy", "exponential");
        rules.add(retryRule);
        
        ObjectNode timeoutRule = objectMapper.createObjectNode();
        timeoutRule.put("type", "timeout");
        timeoutRule.put("timeout", 30000);
        rules.add(timeoutRule);
        
        ObjectNode dedupeRule = objectMapper.createObjectNode();
        ObjectNode dedupeRule = objectMapper.createObjectNode();
        dedupeRule.put("type", "deduplicate");
        dedupeRule.put("window", 300000);
        ArrayNode includeFields = objectMapper.createArrayNode();
        includeFields.add("headers.x-shopify-event-id");
        dedupeRule.set("include_fields", includeFields);
        rules.add(dedupeRule);
        
        payload.set("rules", rules);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.hookdeck.com/2027-07-01/connections"))
                .header("Authorization", "Bearer " + System.getenv("HOOKDECK_API_KEY"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(payload)))
                .timeout(Duration.ofSeconds(30))
                .build();
        
        HttpResponse<String> response = httpClient.send(request,
                HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() >= 200 && response.statusCode() < 300) {
            System.out.println("Connection created: " + response.body());
        } else {
            throw new RuntimeException("Request failed with status: " + response.statusCode());
        }
    }
    
    public static void main(String[] args) {
        try {
            createConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System.Text;
using System.Text.Json;

// Using HttpClient with dependency injection (recommended)
public class HookdeckService
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;

    public HookdeckService(HttpClient httpClient, IConfiguration configuration)
    {
        _httpClient = httpClient;
        _apiKey = configuration["HOOKDECK_API_KEY"];
        
        _httpClient.BaseAddress = new Uri("https://api.hookdeck.com/2027-07-01/");
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    public async Task<object> CreateConnectionAsync()
    {
        var payload = new
        {
            name = "Shopify-to-Production-App",
            source = new
            {
                name = "shopify",
                type = "SHOPIFY",
                config = new
                {
                    auth = new
                    {
                        webhook_secret_key = "your-app-client-secret"
                    }
                }
            },
            destination = new
            {
                name = "Production-App",
                type = "HTTP",
                config = new
                {
                    url = "https://yourapp.com/webhooks/shopify"
                }
            },
            rules = new[]
            {
                new { type = "retry", count = 20, interval = 300, strategy = "exponential" },
                new { type = "timeout", timeout = 30000 },
                new { type = "deduplicate", window = 300000, include_fields = new[] { "headers.x-shopify-event-id" } }
            }
        };

        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        using var response = await _httpClient.PostAsync("connections", content);
        response.EnsureSuccessStatusCode();
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine($"Connection created: {result}");
        
        return JsonSerializer.Deserialize<object>(result);
    }
}

// Usage in Program.cs or controller
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient<HookdeckService>();

var app = builder.Build();
var hookdeckService = app.Services.GetRequiredService<HookdeckService>();
await hookdeckService.CreateConnectionAsync();

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

type ConnectionPayload struct {
    Name        string      `json:"name"`
    Source      Source      `json:"source"`
    Destination Destination `json:"destination"`
    Rules       []Rule      `json:"rules"`
}

type Source struct {
    Name   string       `json:"name"`
    Type   string       `json:"type"`
    Config SourceConfig `json:"config"`
}

type SourceConfig struct {
    Auth Auth `json:"auth"`
}

type Auth struct {
    WebhookSecretKey string `json:"webhook_secret_key"`
}

type Destination struct {
    Name   string          `json:"name"`
    Type   string          `json:"type"`
    Config DestinationConfig `json:"config"`
}

type DestinationConfig struct {
    URL string `json:"url"`
}

type Rule struct {
    Type     string `json:"type"`
    Count    *int   `json:"count,omitempty"`
    Interval *int   `json:"interval,omitempty"`
    Strategy *string `json:"strategy,omitempty"`
    Timeout  *int   `json:"timeout,omitempty"`
    Window       *int      `json:"window,omitempty"`
    IncludeFields *[]string `json:"include_fields,omitempty"`
}

func createConnection() error {
    exponential := "exponential"
    retryCount := 20
    timeout := 30000
    window := 300000
    includeFields := []string{"headers.x-shopify-event-id"}

    payload := ConnectionPayload{
        Name: "Shopify-to-Production-App",
        Source: Source{
            Name: "shopify",
            Type: "SHOPIFY",
            Config: SourceConfig{
                Auth: Auth{
                    WebhookSecretKey: "your-app-client-secret",
                },
            },
        },
        Destination: Destination{
            Name: "Production-App",
            Type: "HTTP",
            Config: DestinationConfig{
                URL: "https://yourapp.com/webhooks/shopify",
            },
        },
        Rules: []Rule{
            {
                Type:     "retry",
                Count:    &retryCount,
                Interval: &interval,
                Strategy: &exponential,
            },
            {
                Type:    "timeout",
                Timeout: &timeout,
            },
            {
                Type:          "deduplicate",
                Window:        &window,
                IncludeFields: &includeFields,
            },
        },
    }
    interval := 300
    timeout := 30000
    payload := ConnectionPayload{
        Name: "Shopify-to-Production-App",
        Source: Source{
            Name: "shopify",
            Type: "SHOPIFY",
            Config: SourceConfig{
                Auth: Auth{
                    WebhookSecretKey: "your-app-client-secret",
                },
            },
        },
        Destination: Destination{
            Name: "Production-App",
            Type: "HTTP",
            Config: DestinationConfig{
                URL: "https://yourapp.com/webhooks/shopify",
            },
        },
        Rules: []Rule{
            {
                Type:     "retry",
                Count:    &retryCount,
                Interval: &interval,
                Strategy: &exponential,
            },
            {
                Type:    "timeout",
                Timeout: &timeout,
            },
            {
                Type:          "deduplicate",
                Window:        &window,
                IncludeFields: &includeFields,
            },
        },
    }
    
    jsonData, err := json.Marshal(payload)
    if err != nil {
        return fmt.Errorf("error marshaling JSON: %v", err)
    }
    
    client := &http.Client{
        Timeout: 30 * time.Second,
    }
    
    req, err := http.NewRequest("POST", "https://api.hookdeck.com/2027-07-01/connections", bytes.NewBuffer(jsonData))
    if err != nil {
        return fmt.Errorf("error creating request: %v", err)
    }
    
    req.Header.Set("Authorization", "Bearer "+os.Getenv("HOOKDECK_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("error making request: %v", err)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return fmt.Errorf("error reading response: %v", err)
    }
    
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        return fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(body))
    }
    
    fmt.Printf("Connection created: %s\n", string(body))
    return nil
}

func main() {
    if err := createConnection(); err != nil {
        fmt.Printf("Error: %v\n", err)
        os.Exit(1)
    }
}

curl -X POST "https://your-shop.myshopify.com/admin/api/2024-01/graphql.json" \
  -H "X-Shopify-Access-Token: YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) { webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) { webhookSubscription { id callbackUrl } userErrors { field message } } }",
    "variables": {
      "topic": "ORDERS_CREATE",
      "webhookSubscription": {
        "callbackUrl": "https://hkdk.events/src_123abc",
        "format": "JSON"
      }
    }
  }'

const response = await fetch('https://your-shop.myshopify.com/admin/api/2024-01/graphql.json', {
  method: 'POST',
  headers: {
    'X-Shopify-Access-Token': process.env.SHOPIFY_ACCESS_TOKEN,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    query: `
      mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
        webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
          webhookSubscription {
            id
            callbackUrl
          }
          userErrors {
            field
            message
          }
        }
      }
    `,
    variables: {
      topic: 'ORDERS_CREATE',
      webhookSubscription: {
        callbackUrl: 'https://hkdk.events/src_123abc',
        format: 'JSON'
      }
    }
  })
});

const result = await response.json();
console.log('Webhook created:', result);

<?php
require_once 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->post('https://your-shop.myshopify.com/admin/api/2024-01/graphql.json', [
    'headers' => [
        'X-Shopify-Access-Token' => $_ENV['SHOPIFY_ACCESS_TOKEN'],
        'Content-Type' => 'application/json'
    ],
    'json' => [
        'query' => '
          mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
            webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
              webhookSubscription {
                id
                callbackUrl
              }
              userErrors {
                field
                message
              }
            }
          }
        ',
        'variables' => [
            'topic' => 'ORDERS_CREATE',
            'webhookSubscription' => [
                'callbackUrl' => 'https://hkdk.events/src_123abc',
                'format' => 'JSON'
            ]
        ]
    ]
]);

$result = json_decode($response->getBody(), true);
echo 'Webhook created: ' . json_encode($result) . "\n";
?>

require 'faraday'
require 'json'

conn = Faraday.new(url: 'https://your-shop.myshopify.com') do |f|
  f.request :json
  f.response :json
  f.adapter Faraday.default_adapter
end

payload = {
  query: '
    mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
      webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
        webhookSubscription {
          id
          callbackUrl
        }
        userErrors {
          field
          message
        }
      }
    }
  ',
  variables: {
    topic: 'ORDERS_CREATE',
    webhookSubscription: {
      callbackUrl: 'https://hkdk.events/src_123abc',
      format: 'JSON'
    }
  }
}

response = conn.post('/admin/api/2024-01/graphql.json') do |req|
  req.headers['X-Shopify-Access-Token'] = ENV['SHOPIFY_ACCESS_TOKEN']
  req.body = payload
end

result = response.body
puts "Webhook created: #{result}"

import httpx
import asyncio
import os

async def create_webhook():
    async with httpx.AsyncClient() as client:
        response = await client.post(
            'https://your-shop.myshopify.com/admin/api/2024-01/graphql.json',
            headers={
                'X-Shopify-Access-Token': os.environ['SHOPIFY_ACCESS_TOKEN'],
                'Content-Type': 'application/json'
            },
            json={
                'query': '''
                  mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
                    webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
                      webhookSubscription {
                        id
                        callbackUrl
                      }
                      userErrors {
                        field
                        message
                      }
                    }
                  }
                ''',
                'variables': {
                    'topic': 'ORDERS_CREATE',
                    'webhookSubscription': {
                        'callbackUrl': 'https://hkdk.events/src_123abc',
                        'format': 'JSON'
                    }
                }
            }
        )
        
        result = response.json()
        print('Webhook created:', result)

# Run the async function
asyncio.run(create_webhook())

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class ShopifyWebhookCreator {
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
    
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    public static void createWebhook() throws Exception {
        ObjectNode payload = objectMapper.createObjectNode();
        
        String query = "mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) { webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) { webhookSubscription { id callbackUrl } userErrors { field message } } }";
        payload.put("query", query);
        
        ObjectNode variables = objectMapper.createObjectNode();
        variables.put("topic", "ORDERS_CREATE");
        
        ObjectNode webhookSubscription = objectMapper.createObjectNode();
        webhookSubscription.put("callbackUrl", "https://hkdk.events/src_123abc");
        webhookSubscription.put("format", "JSON");
        variables.set("webhookSubscription", webhookSubscription);
        
        payload.set("variables", variables);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://your-shop.myshopify.com/admin/api/2024-01/graphql.json"))
                .header("X-Shopify-Access-Token", System.getenv("SHOPIFY_ACCESS_TOKEN"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(payload)))
                .timeout(Duration.ofSeconds(30))
                .build();
        
        HttpResponse<String> response = httpClient.send(request,
                HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() >= 200 && response.statusCode() < 300) {
            System.out.println("Webhook created: " + response.body());
        } else {
            throw new RuntimeException("Request failed with status: " + response.statusCode());
        }
    }
    
    public static void main(String[] args) {
        try {
            createWebhook();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System.Text;
using System.Text.Json;

public class ShopifyWebhookService
{
    private readonly HttpClient _httpClient;
    private readonly string _accessToken;

    public ShopifyWebhookService(HttpClient httpClient, IConfiguration configuration)
    {
        _httpClient = httpClient;
        _accessToken = configuration["SHOPIFY_ACCESS_TOKEN"];
    }

    public async Task<object> CreateWebhookAsync(string shopDomain)
    {
        var payload = new
        {
            query = "mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) { webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) { webhookSubscription { id callbackUrl } userErrors { field message } } }",
            variables = new
            {
                topic = "ORDERS_CREATE",
                webhookSubscription = new
                {
                    callbackUrl = "https://hkdk.events/src_123abc",
                    format = "JSON"
                }
            }
        };

        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        using var request = new HttpRequestMessage(HttpMethod.Post, $"https://{shopDomain}.myshopify.com/admin/api/2024-01/graphql.json")
        {
            Content = content
        };
        request.Headers.Add("X-Shopify-Access-Token", _accessToken);

        using var response = await _httpClient.SendAsync(request);
        response.EnsureSuccessStatusCode();
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine($"Webhook created: {result}");
        
        return JsonSerializer.Deserialize<object>(result);
    }
}

// Usage
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient<ShopifyWebhookService>();

var app = builder.Build();
var webhookService = app.Services.GetRequiredService<ShopifyWebhookService>();
await webhookService.CreateWebhookAsync("your-shop");

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

type WebhookPayload struct {
    Query     string    `json:"query"`
    Variables Variables `json:"variables"`
}

type Variables struct {
    Topic              string             `json:"topic"`
    WebhookSubscription WebhookSubscription `json:"webhookSubscription"`
}

type WebhookSubscription struct {
    CallbackURL string `json:"callbackUrl"`
    Format      string `json:"format"`
}

func createWebhook() error {
    payload := WebhookPayload{
        Query: "mutation webhookSubscriptionCreate($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) { webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) { webhookSubscription { id callbackUrl } userErrors { field message } } }",
        Variables: Variables{
            Topic: "ORDERS_CREATE",
            WebhookSubscription: WebhookSubscription{
                CallbackURL: "https://hkdk.events/src_123abc",
                Format:      "JSON",
            },
        },
    }
    
    jsonData, err := json.Marshal(payload)
    if err != nil {
        return fmt.Errorf("error marshaling JSON: %v", err)
    }
    
    client := &http.Client{
        Timeout: 30 * time.Second,
    }
    
    req, err := http.NewRequest("POST", "https://your-shop.myshopify.com/admin/api/2024-01/graphql.json", bytes.NewBuffer(jsonData))
    if err != nil {
        return fmt.Errorf("error creating request: %v", err)
    }
    
    req.Header.Set("X-Shopify-Access-Token", os.Getenv("SHOPIFY_ACCESS_TOKEN"))
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("error making request: %v", err)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return fmt.Errorf("error reading response: %v", err)
    }
    
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        return fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(body))
    }
    
    fmt.Printf("Webhook created: %s\n", string(body))
    return nil
}

func main() {
    if err := createWebhook(); err != nil {
        fmt.Printf("Error: %v\n", err)
        os.Exit(1)
    }
}

# Retry specific event by ID
curl -X POST "https://api.hookdeck.com/2027-07-01/events/evt_789ghi/retry" \
  -H "Authorization: Bearer $HOOKDECK_API_KEY"

const response = await fetch('https://api.hookdeck.com/2027-07-01/events/evt_789ghi/retry', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.HOOKDECK_API_KEY}`
  }
});

const result = await response.json();
console.log('Event retried:', result);

<?php
require_once 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->post('https://api.hookdeck.com/2027-07-01/events/evt_789ghi/retry', [
    'headers' => [
        'Authorization' => 'Bearer ' . $_ENV['HOOKDECK_API_KEY']
    ]
]);

$result = json_decode($response->getBody(), true);
echo 'Event retried: ' . json_encode($result) . "\n";
?>

require 'faraday'
require 'json'

conn = Faraday.new(url: 'https://api.hookdeck.com') do |f|
  f.request :json
  f.response :json
  f.adapter Faraday.default_adapter
end

response = conn.post('/2027-07-01/events/evt_789ghi/retry') do |req|
  req.headers['Authorization'] = "Bearer #{ENV['HOOKDECK_API_KEY']}"
end

result = response.body
puts "Event retried: #{result}"

import httpx
import asyncio
import os

async def retry_event():
    async with httpx.AsyncClient() as client:
        response = await client.post(
            'https://api.hookdeck.com/2027-07-01/events/evt_789ghi/retry',
            headers={
                'Authorization': f'Bearer {os.environ["HOOKDECK_API_KEY"]}'
            }
        )
        
        result = response.json()
  print('Event retried:', result)

# Run the async function
asyncio.run(retry_event())

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;

public class EventRetry {
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
    
  public static void retryEvent() throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.hookdeck.com/2027-07-01/events/evt_789ghi/retry"))
                .header("Authorization", "Bearer " + System.getenv("HOOKDECK_API_KEY"))
                .POST(HttpRequest.BodyPublishers.noBody())
                .timeout(Duration.ofSeconds(30))
                .build();
        
        HttpResponse<String> response = httpClient.send(request,
                HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() >= 200 && response.statusCode() < 300) {
            System.out.println("Event retried: " + response.body());
        } else {
            throw new RuntimeException("Request failed with status: " + response.statusCode());
        }
    }
    
    public static void main(String[] args) {
        try {
            retryEvent();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}