Webconnex API

https://docs.webconnex.io/api/v2/
Admin
Webconnex API is a REST-based API service providing access to Webconnex products including RegFox,...
Tokens:140,646
Snippets:404
Trust Score:5
Update:7 months ago
Show doc for...
Tokens:
Raw
### View Membership by ID using Go

Source: https://docs.webconnex.io/api/v2

This Go code example shows how to fetch membership data using the `net/http` package. It constructs an HTTP GET request with the necessary headers and displays the response status, headers, and body. Ensure you replace the placeholder API key.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func view() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/memberships/2233110?product=regfox.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### Search Subscriptions via Webconnex API

Source: https://docs.webconnex.io/api/v2/#introduction

Demonstrates how to query the subscription search endpoint using an API key and product filter. The examples handle the HTTP GET request and process the resulting subscription data.

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/search/subscriptions",
            params={
                "product": "givingfuel.com",
            },
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')
```

```javascript
(function(callback) {
    'use strict';

    const httpTransport = require('https');
    const responseEncoding = 'utf8';
    const httpOptions = {
        hostname: 'api.webconnex.com',
        port: '443',
        path: '/v2/public/search/subscriptions?product=givingfuel.com',
        method: 'GET',
        headers: {"apiKey":"<YOUR API KEY>"}
    };
    httpOptions.headers['User-Agent'] = 'node ' + process.version;

    const request = httpTransport.request(httpOptions, (res) => {
        let responseBufs = [];
        let responseStr = '';

        res.on('data', (chunk) => {
            if (Buffer.isBuffer(chunk)) {
                responseBufs.push(chunk);
            }
            else {
                responseStr = responseStr + chunk;            
            }
        }).on('end', () => {
            responseStr = responseBufs.length > 0 ?
                Buffer.concat(responseBufs).toString(responseEncoding) : responseStr;

            callback(null, res.statusCode, res.headers, responseStr);
        });

    })
    .setTimeout(0)
    .on('error', (error) => {
        callback(error);
    });
    request.write("")
    request.end();

})((error, statusCode, headers, body) => {
    console.log('ERROR:', error);
    console.log('STATUS:', statusCode);
    console.log('HEADERS:', JSON.stringify(headers));
    console.log('BODY:', body);
});
```

```swift
func searchRequest() {

    // Add Headers
    let headers = [
        "apiKey":"<YOUR API KEY>",
    ]

    // Add URL parameters
    let urlParams = [
        "product":"givingfuel.com",
    ]

    // Fetch Request
    Alamofire.request("https://api.webconnex.com/v2/public/search/subscriptions", method: .get, parameters: urlParams, headers: headers)
        .validate(statusCode: 200..<300)
        .responseJSON { response in
            if (response.result.error == nil) {
                debugPrint("HTTP Response Body: \(response.data)")
            }
            else {
                debugPrint("HTTP Request failed: \(response.result.error)")
            }
        }
}
```

--------------------------------

### Get Webhook Logs using Swift (Alamofire)

Source: https://docs.webconnex.io/api/v2

This Swift code example demonstrates how to fetch webhook logs using the Alamofire library. It defines a function `sendListRequest` that constructs the necessary headers and makes a GET request to the API. The response is then processed to print either the data or any errors encountered. Ensure Alamofire is added to your project.

```swift
import Alamofire

func sendListRequest() {

    // Add Headers
    let headers = [
        "apiKey":"<YOUR API KEY>",
    ]

    // Fetch Request
    Alamofire.request("https://api.webconnex.com/v2/public/webhooks/1623423/logs", method: .get, headers: headers)
        .validate(statusCode: 200..<300)
        .responseJSON { response in
            if (response.result.error == nil) {
                debugPrint("HTTP Response Body: \(response.data)")
            }
            else {
                debugPrint("HTTP Request failed: \(response.result.error)")
            }
        }
}
```

--------------------------------

### Search Tickets using Go

Source: https://docs.webconnex.io/api/v2

This Go program demonstrates how to search for tickets using the Webconnex API v2. It constructs an HTTP GET request with the necessary API key and product parameter, then prints the response status, headers, and body. Ensure you have the Go standard library installed.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func search() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/tickets?product=ticketspice.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### Search Orders using Go

Source: https://docs.webconnex.io/api/v2/#introduction

This Go program sends a GET request to the API's order search endpoint. It includes necessary headers, handles potential errors during the request, and prints the response status, headers, and body. Ensure you have the Go programming language installed.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func search() {
 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/orders?product=redpodium.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}

```

--------------------------------

### Search Memberships using Go

Source: https://docs.webconnex.io/api/v2

This Go program illustrates how to perform a search for memberships using the `net/http` package. It includes setting up the HTTP client, creating the request, adding the necessary API key header, and processing the response.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func search() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/memberships?product=regfox.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### Get Webhook Logs using Python (requests)

Source: https://docs.webconnex.io/api/v2

This Python script uses the 'requests' library to make a GET request to the Webconnex API to retrieve webhook logs. It includes error handling for network issues and prints the status code and response content. Ensure you have the 'requests' library installed (`pip install requests`).

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/webhooks/1623423/logs",
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')

send_request()
```

--------------------------------

### Create Coupon using Go

Source: https://docs.webconnex.io/api/v2

This Go program demonstrates how to create a coupon by making an HTTP POST request to the Webconnex API. It includes setting the API key and content type headers, and sending the coupon details as a JSON payload. Error handling for the request and response is included.

```go
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://api.webconnex.com/v2/public/coupons?pretty=true"
  method := "POST"

  payload := strings.NewReader(`{
    "name": "example create",
    "currency": "USD",
    "available": 1,
    "formId": 23,
    "productId": 4,
    "discounts": [{
        "perTicket": false,
        "value": "1",
        "valueType": "fixed"
    }],
    "codes": [{
        "code": "coupon code here"
    }],
    "expires": "2016-10-10T17:14:16Z"
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("apiKey", "<YOUR API KEY>")
  req.Header.Add("Content-Type", "application/json; charset=utf-8")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

--------------------------------

### Search Registrants with Python Requests

Source: https://docs.webconnex.io/api/v2/#introduction

This Python code snippet demonstrates how to search for registrants using the 'requests' library. It sends a GET request to the Webconnex API v2 and prints the status code and response content. Ensure you have the 'requests' library installed (`pip install requests`).

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/search/registrants/2233110",
            params={
                "product": "redpodium.com",
            },
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')
send_request()
```

--------------------------------

### Send Health Check Request using Python

Source: https://docs.webconnex.io/api/v2/#introduction

This Python function uses the 'requests' library to send a GET request to the API's ping endpoint for a health check. It prints the HTTP status code and response body. Ensure you have the 'requests' library installed (`pip install requests`).

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/ping",
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')

```

--------------------------------

### Search Customers using Go

Source: https://docs.webconnex.io/api/v2

This Go program demonstrates how to search for customers using the Webconnex API v2. It utilizes the standard Go `net/http` package to make a GET request, including the necessary API key in the headers. The response status, headers, and body are then printed.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func search() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/customers?product=redpodium.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := ioutil.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### Fetch Webhook Log Details using Python Requests

Source: https://docs.webconnex.io/api/v2

This Python snippet demonstrates how to fetch details of a specific webhook log using the `requests` library. It sends a GET request to the Webconnex API and prints the status code and response content. Ensure you have the `requests` library installed (`pip install requests`).

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/webhooks/46/logs/9849",
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')

send_request()
```

--------------------------------

### List Forms using Python Requests

Source: https://docs.webconnex.io/api/v2

Fetches a list of forms from the Webconnex API v2 using the Python 'requests' library. Requires the 'requests' library to be installed (`pip install requests`). It sends a GET request to the forms endpoint with specified parameters and headers, printing the status code and response content.

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/forms",
            params={
                "product": "redpodium.com",
            },
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')
send_request()
```

--------------------------------

### Search Subscriptions using Go

Source: https://docs.webconnex.io/api/v2

This Go program demonstrates how to search for subscriptions using the Webconnex API v2. It constructs an HTTP GET request with the necessary headers and endpoint, then prints the response status, headers, and body. Ensure you replace '<YOUR API KEY>' with your actual API key.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func search() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/subscriptions?product=givingfuel.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### List Forms using Go

Source: https://docs.webconnex.io/api/v2/#introduction

This Go code snippet shows how to make a GET request to the Webconnex API v2 to list forms. It includes setting up an HTTP client, creating a request with the necessary headers (apiKey) and query parameters (product), sending the request, and printing the response status, headers, and body. Ensure you replace '<YOUR API KEY>' with your actual API key.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func sendRequest() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/forms?product=redpodium.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}

```

--------------------------------

### Search Transactions via Webconnex API

Source: https://docs.webconnex.io/api/v2/#introduction

Demonstrates how to perform a GET request to the Webconnex transaction search endpoint. These examples require an API key for authentication and filter results by product.

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/search/transactions",
            params={"product": "regfox.com"},
            headers={"apiKey": "<YOUR API KEY>"}
        )
        print(f'Status Code: {response.status_code}')
        print(f'Body: {response.content}')
    except requests.exceptions.RequestException:
        print('HTTP Request failed')
```

```javascript
const httpTransport = require('https');
const httpOptions = {
    hostname: 'api.webconnex.com',
    path: '/v2/public/search/transactions?product=regfox.com',
    method: 'GET',
    headers: {"apiKey": "<YOUR API KEY>"}
};

const request = httpTransport.request(httpOptions, (res) => {
    let responseStr = '';
    res.on('data', (chunk) => { responseStr += chunk; });
    res.on('end', () => { console.log(responseStr); });
});
request.end();
```

```swift
import Alamofire

func searchRequest() {
    let headers = ["apiKey": "<YOUR API KEY>"]
    let urlParams = ["product": "regfox.com"]

    Alamofire.request("https://api.webconnex.com/v2/public/search/transactions", method: .get, parameters: urlParams, headers: headers)
        .responseJSON { response in
            if let data = response.data {
                debugPrint("Response: \(data)")
            }
        }
}
```

--------------------------------

### View Customer by ID using Go

Source: https://docs.webconnex.io/api/v2

This Go program shows how to fetch customer data by ID using the `net/http` package. It constructs an HTTP GET request with necessary headers and prints the response status, headers, and body. Ensure you have the correct API key.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func view() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/customers/1155061?product=redpodium.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### Node.js: Send GET Request to Search Orders

Source: https://docs.webconnex.io/api/v2

This Node.js example utilizes the built-in 'https' module to perform a GET request to the Webconnex API for searching orders. It configures request options including hostname, path, method, and headers, and handles the response data by concatenating buffer chunks. The callback function logs any errors, status codes, headers, and the response body.

```javascript
(function(callback) {
    'use strict';

    const httpTransport = require('https');
    const responseEncoding = 'utf8';
    const httpOptions = {
        hostname: 'api.webconnex.com',
        port: '443',
        path: '/v2/public/search/orders?product=redpodium.com',
        method: 'GET',
        headers: {"apiKey":"<YOUR API KEY>"}
    };
    httpOptions.headers['User-Agent'] = 'node ' + process.version;



    const request = httpTransport.request(httpOptions, (res) => {
        let responseBufs = [];
        let responseStr = '';

        res.on('data', (chunk) => {
            if (Buffer.isBuffer(chunk)) {
                responseBufs.push(chunk);
            }
            else {
                responseStr = responseStr + chunk;
            }
        }).on('end', () => {
            responseStr = responseBufs.length > 0 ?
                Buffer.concat(responseBufs).toString(responseEncoding) : responseStr;

            callback(null, res.statusCode, res.headers, responseStr);
        });

    })
    .setTimeout(0)
    .on('error', (error) => {
        callback(error);
    });
    request.write("")
    request.end();

})((error, statusCode, headers, body) => {
    console.log('ERROR:', error);
    console.log('STATUS:', statusCode);
    console.log('HEADERS:', JSON.stringify(headers));
    console.log('BODY:', body);
});
```

--------------------------------

### Search Registrants using Go

Source: https://docs.webconnex.io/api/v2/#introduction

This Go program illustrates how to search for registrants using the Webconnex API v2. It utilizes the `net/http` package to construct and execute the GET request, including necessary headers and error handling. The response includes status, headers, and the JSON body.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func search() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/registrants?product=redpodium.com2", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### View Subscription by ID using Go

Source: https://docs.webconnex.io/api/v2

This Go program shows how to fetch subscription details by ID using the `net/http` package. It constructs an HTTP GET request with the necessary headers and URL parameters. The response status, headers, and body are then printed.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func view() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/search/subscriptions/49675?product=givingfuel.com", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### Resend Webhook using Go

Source: https://docs.webconnex.io/api/v2

This Go program demonstrates how to resend a webhook using the Go standard library's `net/http` package. It constructs a POST request with the necessary API key header and prints the response status, headers, and body.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func sendRequest() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("POST", "https://api.webconnex.com/v2/public/webhooks/39/resend/3899", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```

--------------------------------

### List Forms using Node.js HTTPS

Source: https://docs.webconnex.io/api/v2

Retrieves a list of forms from the Webconnex API v2 using Node.js's built-in 'https' module. This code makes a GET request to the API endpoint, handling the response data and callback. It requires Node.js to be installed.

```javascript
(function(callback) {
     'use strict';

     const httpTransport = require('https');
     const responseEncoding = 'utf8';
     const httpOptions = {
         hostname: 'api.webconnex.com',
         port: '443',
         path: '/v2/public/forms?product=redpodium.com',
         method: 'GET',
         headers: {"apiKey":"<YOUR API KEY>"}
     };
     httpOptions.headers['User-Agent'] = 'node ' + process.version;

     const request = httpTransport.request(httpOptions, (res) => {
         let responseBufs = [];
         let responseStr = '';

         res.on('data', (chunk) => {
             if (Buffer.isBuffer(chunk)) {
                 responseBufs.push(chunk);
             }
             else {
                 responseStr = responseStr + chunk;            
             }
         }).on('end', () => {
             responseStr = responseBufs.length > 0 ?
                 Buffer.concat(responseBufs).toString(responseEncoding) : responseStr;

             callback(null, res.statusCode, res.headers, responseStr);
         });
     })
     .setTimeout(0)
     .on('error', (error) => {
         callback(error);
     });
     request.write("")
     request.end();

 })((error, statusCode, headers, body) => {
     console.log('ERROR:', error);
     console.log('STATUS:', statusCode);
     console.log('HEADERS:', JSON.stringify(headers));
     console.log('BODY:', body);
 });
```

--------------------------------

### View Form Inventory using Go net/http

Source: https://docs.webconnex.io/api/v2

This Go snippet shows how to fetch form inventory data using the standard net/http package. It constructs an HTTP GET request, adds the required API key header, sends the request, and then prints the response status, headers, and body.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func sendRequest() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/forms/676/inventory", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}


```

--------------------------------

### Search Registrants with Node.js HTTPS

Source: https://docs.webconnex.io/api/v2/#introduction

This Node.js code snippet shows how to search for registrants using the built-in 'https' module. It makes a GET request to the Webconnex API v2, handling the response data and callback. This example does not require external dependencies beyond Node.js itself.

```javascript
(function(callback) {
    'use strict';

    const httpTransport = require('https');
    const responseEncoding = 'utf8';
    const httpOptions = {
        hostname: 'api.webconnex.com',
        port: '443',
        path: '/v2/public/search/registrants/2233110?product=redpodium.com',
        method: 'GET',
        headers: {"apiKey":"<YOUR API KEY>"}
    };
    httpOptions.headers['User-Agent'] = 'node ' + process.version;

    const request = httpTransport.request(httpOptions, (res) => {
        let responseBufs = [];
        let responseStr = '';

        res.on('data', (chunk) => {
            if (Buffer.isBuffer(chunk)) {
                responseBufs.push(chunk);
            }
            else {
                responseStr = responseStr + chunk;
            }
        }).on('end', () => {
            responseStr = responseBufs.length > 0 ?
                Buffer.concat(responseBufs).toString(responseEncoding) : responseStr;

            callback(null, res.statusCode, res.headers, responseStr);
        });
    })
    .setTimeout(0)
    .on('error', (error) => {
        callback(error);
    });
    request.write("")
    request.end();

})((error, statusCode, headers, body) => {
    console.log('ERROR:', error);
    console.log('STATUS:', statusCode);
    console.log('HEADERS:', JSON.stringify(headers));
    console.log('BODY:', body);
});
```

--------------------------------

### Create Coupon using JavaScript (Fetch API)

Source: https://docs.webconnex.io/api/v2

This JavaScript example uses the Fetch API to create a coupon. It configures the request method, headers (including the API key), and the JSON body. The response is processed to log the result or any errors encountered.

```javascript
var myHeaders = new Headers();
myHeaders.append("apiKey", "<YOUR API KEY>");
myHeaders.append("Content-Type", "application/json; charset=utf-8");

var raw = 
 '{\n    \"name\": \"example create\",\n    \"currency\": \"USD\",\n    \"available\": 1,\n    \"formId\": 23,\n    \"productId\": 4,\n    \"discounts\": [{\n        \"perTicket\": false,\n        \"value\": \"1\",\n        \"valueType\": \"fixed\"\n    }],\n    \"codes\": [{\n        \"code\": \"coupon code here\"\n    }],\n    \"expires\": \"2016-10-10T17:14:16Z\"\n}';

var requestOptions = {
 method: "POST",
 headers: myHeaders,
 body: raw,
 redirect: "follow",
};

fetch("https://api.webconnex.com/v2/public/coupons?pretty=true", requestOptions)
 .then((response) => response.text())
 .then((result) => console.log(result))
 .catch((error) => console.log("error", error));
```

--------------------------------

### Pagination and Expansion

Source: https://docs.webconnex.io/api/v2

Guidelines for using cursor-based pagination and resource expansion across collection endpoints.

```APIDOC
## Pagination and Expansion

### Pagination
Webconnex uses cursor-based pagination for collection resources.
- **sort** (string) - Optional - Sets order: 'asc' or 'desc'.
- **limit** (string) - Optional - Number of objects to return (1-50, default 50).
- **startingAfter** (integer) - Required - The object ID defining the start of the current page.

### Expand
Use the `[]expand` parameter to include child resource details in the response.
- **[]expand** (array) - Optional - Comma-separated list of child resources to include (e.g., registrants, tickets, subscription).
```

--------------------------------

### Create Coupon using Swift

Source: https://docs.webconnex.io/api/v2

This Swift code snippet demonstrates how to create a coupon using URLSession. It sets up a URLRequest with the necessary headers and HTTP body containing the coupon details in JSON format. The code includes basic error handling and semaphore usage for asynchronous operations.

```swift
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

var semaphore = DispatchSemaphore (value: 0)

let parameters = "{\n    \"name\": \"example create\",\n    \"currency\": \"USD\",\n    \"available\": 1,\n    \"formId\": 23,\n    \"productId\": 4,\n    \"discounts\": [{\n        \"perTicket\": false,\n        \"value\": \"1\",\n        \"valueType\": \"fixed\"\n    }],\n    \"codes\": [{\n        \"code\": \"coupon code here\"\n    }],\n    \"expires\": \"2016-10-10T17:14:16Z\"\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "https://api.webconnex.com/v2/public/coupons?pretty=true")!,timeoutInterval: Double.infinity)
request.addValue("<YOUR API KEY>", forHTTPHeaderField: "apiKey")
request.addValue("application/json; charset=utf-8", forHTTPHeaderField: "Content-Type")

request.httpMethod = "POST"
request.httpBody = postData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data else {
    print(String(describing: error))
    semaphore.signal()
    return
  }
  print(String(data: data, encoding: .utf8)!)
  semaphore.signal()
}

task.resume()
semaphore.wait()
```

--------------------------------

### View Webhook using Python

Source: https://docs.webconnex.io/api/v2

This Python code uses the 'requests' library to fetch webhook details from the Webconnex API. Ensure you have the library installed (`pip install requests`). It handles potential request exceptions.

```python
# Install the Python Requests library:
# `pip install requests`

import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/webhooks/1623423",
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')
```

--------------------------------

### Install Python Requests Library

Source: https://docs.webconnex.io/api/v2

This is a comment indicating the need to install the Python Requests library, which is commonly used for making HTTP requests in Python applications. This library simplifies the process of interacting with web APIs.

```python
# Install the Python Requests library:
```

--------------------------------

### Create Webhook using Go

Source: https://docs.webconnex.io/api/v2

This Go code snippet illustrates how to create a webhook subscription via the Webconnex API v2. It constructs an HTTP POST request with the webhook details in the request body and includes the API key in the headers. The code handles request creation, sending, and reading the response. Remember to replace '<YOUR API KEY>' with your valid API key.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
 "strings"
)

func sendRequest() {
 body := strings.NewReader(`{
    "accountId": 1,
    "events": [
        "registration"
    ],
    "forms": [
        {
        "formId": -1
        }
    ],
    "meta": {
        "name": "Divvy API TEST Create"
    },
    "method": "POST",
    "status": 1,
    "typeId": 1,
    "url": "https://example.com"
 }`)

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("POST", "https://api.webconnex.com/v2/public/webhooks", body)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")
 req.Header.Add("Content-Type", "text/plain; charset=utf-8")

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}

```

--------------------------------

### Implement Cursor-Based Pagination

Source: https://docs.webconnex.io/api/v2/#introduction

Demonstrates how to paginate through resource collections using the startingAfter and limit URI parameters. This pattern is applicable to any endpoint returning a collection of objects.

```HTTP
https://api.webconnex.com/parent?limit=100&startingAfter=45&sort=desc
```

--------------------------------

### Retrieve Form Data via GET Request

Source: https://docs.webconnex.io/api/v2

Demonstrates how to perform a GET request to the Webconnex API to fetch specific form details. Each implementation includes the necessary headers for authentication and query parameters for data expansion.

```python
import requests

def send_request():
    try:
        response = requests.get(
            url="https://api.webconnex.com/v2/public/forms/123123",
            params={
                "[]expand": "inventory",
            },
            headers={
                "apiKey": "<YOUR API KEY>",
            },
        )
        print('Response HTTP Status Code: {status_code}'.format(
            status_code=response.status_code))
        print('Response HTTP Response Body: {content}'.format(
            content=response.content))
    except requests.exceptions.RequestException:
        print('HTTP Request failed')
```

```javascript
(function(callback) {
    'use strict';

    const httpTransport = require('https');
    const responseEncoding = 'utf8';
    const httpOptions = {
        hostname: 'api.webconnex.com',
        port: '443',
        path: '/v2/public/forms/123123?%5B%5Dexpand=inventory',
        method: 'GET',
        headers: {"apiKey":"<YOUR API KEY>"}
    };
    httpOptions.headers['User-Agent'] = 'node ' + process.version;

    const request = httpTransport.request(httpOptions, (res) => {
        let responseBufs = [];
        let responseStr = '';

        res.on('data', (chunk) => {
            if (Buffer.isBuffer(chunk)) {
                responseBufs.push(chunk);
            }
            else {
                responseStr = responseStr + chunk;            
            }
        }).on('end', () => {
            responseStr = responseBufs.length > 0 ?
                Buffer.concat(responseBufs).toString(responseEncoding) : responseStr;

            callback(null, res.statusCode, res.headers, responseStr);
        });
    })
    .setTimeout(0)
    .on('error', (error) => {
        callback(error);
    });
    request.write("")
    request.end();

})((error, statusCode, headers, body) => {
    console.log('ERROR:', error);
    console.log('STATUS:', statusCode);
    console.log('HEADERS:', JSON.stringify(headers));
    console.log('BODY:', body);
});
```

```swift
func viewRequest() {

    // Add Headers
    let headers = [
        "apiKey":"<YOUR API KEY>",
    ]

    // Add URL parameters
    let urlParams = [
        "pretty":"true",
        "[]expand":"inventory",
    ]

    // Fetch Request
    Alamofire.request("https://api.webconnex.com/v2/public/forms/123123", method: .get, parameters: urlParams, headers: headers)
        .validate(statusCode: 200..<300)
        .responseJSON { response in
            if (response.result.error == nil) {
                debugPrint("HTTP Response Body: \(response.data)")
            }
            else {
                debugPrint("HTTP Request failed: \(response.result.error)")
            }
        }
}
```

--------------------------------

### Retrieve Ticket Edit/Cancel Webhook Payload Example

Source: https://docs.webconnex.io/api/v2

An example JSON payload representing a ticket_edit event. It contains the event metadata, account identifiers, and a comprehensive data object detailing the ticket transaction, fees, and order information.

```json
{
    "eventType": "ticket_edit",
    "accountId": 14,
    "formId": 44519,
    "eventId": 21307,
    "data": {
        "amount": 50,
        "currency": "USD",
        "data": [
            {
                "amount": "5",
                "fees": [
                    {
                        "amount": "5",
                        "fee": {
                            "type": "fixed",
                            "value": "5"
                        },
                        "key": "lineItemFee",
                        "type": "lineItemFee"
                    }
                ],
                "key": "fee",
                "label": "Fee",
                "type": "lineItem"
            }
        ],
        "fee": 5,
        "formId": 44519,
        "formName": "Orchid Farm",
        "id": "01F3TT1Y2FAZ1H4A1JW",
        "lookupId": 21307,
        "source": "standard",
        "status": "completed",
        "label": "Adult VIP",
        "selectedDate": "2021-04-30T00:00:00Z",
        "eventKey": "ticketLevelTwo",
        "eventLabel": "Level Two",
        "ticketTimestamp": "2021-04-21T18:11:12Z",
        "timeslot": "09:00:00",
        "total": 55,
        "orderId": "234SDFSADF1F3TT1Y2JW",
        "orderNumber": "CNFRMTNPGF-AWE-2"
    },
    "meta": {
        "appKey": "Optional App Key",
        "name": "Push Notifications"
    }
}
```

--------------------------------

### List Webhook Logs (Go)

Source: https://docs.webconnex.io/api/v2

This Go program shows how to fetch webhook logs from the Webconnex API. It constructs an HTTP GET request, includes the necessary API key header, and prints the response status, headers, and body.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func list() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/webhooks/1623423/logs", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}

```

--------------------------------

### Example Coupons Notification Payload (JSON)

Source: https://docs.webconnex.io/api/v2

This JSON object represents an example payload for the Coupons Notification event. It includes details about the event type, account, form, and the specific coupon data, along with associated meta information.

```json
{
    "eventType": "coupon",
    "accountId": 1,
    "formId": 112,
    "eventId": 5675,
    "data": {
        "available": -1,
        "codes": [
            {
                "code": "half_off",
                "couponId": 343,
                "id": 3345,
                "redeemed": 3
            }
        ],
        "couponId": 343,
        "currency": "USD",
        "dateCreated": "2016-12-29T06:14:28Z",
        "dateUpdated": "2017-03-03T20:38:48Z",
        "discounts": [
            {
                "paths": ["registrants.registrationOptions.option1"],
                "perTicket": false,
                "value": "50",
                "valueType": "percent"
            }
        ],
        "formId": 29815,
        "name": "Social Media Campaign",
        "redeemed": 3,
        "voucher": false
    },
    "meta": {
        "appKey": "Optional App Key",
        "name": "Push Notifications"
    }
}

```

--------------------------------

### List Form Coupons using Go

Source: https://docs.webconnex.io/api/v2

This Go code demonstrates how to make an HTTP GET request to the Webconnex API to list coupons for a form. It includes setting headers and reading the response.

```go
package main

import (
 "fmt"
 "io/ioutil"
 "net/http"
)

func sendListByForm() {

 // Create client
 client := &http.Client{}

 // Create request
 req, err := http.NewRequest("GET", "https://api.webconnex.com/v2/public/coupons/forms/28609", nil)

 // Headers
 req.Header.Add("apiKey", "<YOUR API KEY>")

 parseFormErr := req.ParseForm()
 if parseFormErr != nil {
   fmt.Println(parseFormErr)
 }

 // Fetch Request
 resp, err := client.Do(req)

 if err != nil {
  fmt.Println("Failure : ", err)
 }

 // Read Response Body
 respBody, _ := io.ReadAll(resp.Body)

 // Display Results
 fmt.Println("response Status : ", resp.Status)
 fmt.Println("response Headers : ", resp.Header)
 fmt.Println("response Body : ", string(respBody))
}
```
Tokens:
Raw