Our Delivery API

Overview

With the AdUp Delivery API, you can programmatically integrate, update, and remove advertisements on your website.

To do this, the API provides the global JavaScript object window.uAd and supports both Responsive Ads and Static Ads.

The Delivery API is particularly suitable for:

• dynamic websites

• Single Page Applications (SPA)

• complex publisher integrations

• programmatic ad placements

Prerequisites

Before using the Delivery API, you will need:

• a registered website

• an ad block in your publisher account

• a valid placementkey

Additionally, the Delivery API must be loaded once on the page.

Loading the Delivery API

The API must be loaded only once per page view.

If it is integrated multiple times, the initialization callback may be executed multiple times, which can cause ads to load repeatedly.

Depending on the project, various options are available.

Standard Integration (recommended)

For most websites, standard integration is sufficient.

After the API is loaded, the callback function window.uAd_init() is executed automatically.

<script>window.uAd_init = function () {    // Initialize ads};if (typeof window.uAd === "object") {    window.uAd_init();} else {    (function(d, t) {        var g = d.createElement(t),            s = d.getElementsByTagName(t)[0];        g.src = "https://s.d.adup-tech.com/jsapi";        g.async = true;        s.parentNode.insertBefore(g, s);    }(document, "script"));}</script>

<script>window.uAd_init = function () {    // Initialize ads};if (typeof window.uAd === "object") {    window.uAd_init();} else {    (function(d, t) {        var g = d.createElement(t),            s = d.getElementsByTagName(t)[0];        g.src = "https://s.d.adup-tech.com/jsapi";        g.async = true;        s.parentNode.insertBefore(g, s);    }(document, "script"));}</script>

<script>window.uAd_init = function () {    // Initialize ads};if (typeof window.uAd === "object") {    window.uAd_init();} else {    (function(d, t) {        var g = d.createElement(t),            s = d.getElementsByTagName(t)[0];        g.src = "https://s.d.adup-tech.com/jsapi";        g.async = true;        s.parentNode.insertBefore(g, s);    }(document, "script"));}</script>

Suitable for:

• classic websites

• few ad placements

• simple integrations

Advanced Integration

For more complex websites, a global helper function is recommended.

This ensures that the API is only loaded once, even if ads are added dynamically at a later stage.

This variant is particularly suitable for:

• Single Page Applications

• React

• Vue

• Angular

• dynamic page content

function adup(callback) {    if (window.uAd) {        callback();    } else if (window.uAd_init) {        const oldCallback = window.uAd_init;        window.uAd_init = function () {            oldCallback();            callback();        };    } else {        window.uAd_init = callback;        (function(d, t) {            var g = d.createElement(t),                s = d.getElementsByTagName(t)[0];            g.src = "https://s.d.adup-tech.com/jsapi";            g.async = true;            s.parentNode.insertBefore(g, s);        }(document, "script"));    }}

function adup(callback) {    if (window.uAd) {        callback();    } else if (window.uAd_init) {        const oldCallback = window.uAd_init;        window.uAd_init = function () {            oldCallback();            callback();        };    } else {        window.uAd_init = callback;        (function(d, t) {            var g = d.createElement(t),                s = d.getElementsByTagName(t)[0];            g.src = "https://s.d.adup-tech.com/jsapi";            g.async = true;            s.parentNode.insertBefore(g, s);        }(document, "script"));    }}

function adup(callback) {    if (window.uAd) {        callback();    } else if (window.uAd_init) {        const oldCallback = window.uAd_init;        window.uAd_init = function () {            oldCallback();            callback();        };    } else {        window.uAd_init = callback;        (function(d, t) {            var g = d.createElement(t),                s = d.getElementsByTagName(t)[0];            g.src = "https://s.d.adup-tech.com/jsapi";            g.async = true;            s.parentNode.insertBefore(g, s);        }(document, "script"));    }}

Subsequently, ads can be integrated at any time.

adup(function () { // Integrate ads});

AMD / RequireJS

Alternatively, the Delivery API can also be integrated as an AMD module.

This variant is suitable for projects that use RequireJS or a compatible AMD loader.

var require = { paths: { uAd: "https://s.d.adup-tech.com/jsapi" }};

The API can then be loaded.

require(["uAd"], function () { // Use ads});

Integrating Ads

embed()

An ad block is generated inside an existing HTML container using window.uAd.embed().

Syntax:

window.uAd.embed("container-id", { placementkey: "..."});

Example

<div id="adup1"></div><script>window.uAd_init = function () {    window.uAd.embed("adup1", {        placementkey: "dd9e2c6e8a1ec4bc5d1561564fcf946d",        responsive: false    });};<

<div id="adup1"></div><script>window.uAd_init = function () {    window.uAd.embed("adup1", {        placementkey: "dd9e2c6e8a1ec4bc5d1561564fcf946d",        responsive: false    });};<

<div id="adup1"></div><script>window.uAd_init = function () {    window.uAd.embed("adup1", {        placementkey: "dd9e2c6e8a1ec4bc5d1561564fcf946d",        responsive: false    });};<

Once called, the API automatically generates an iFrame inside the specified container.

Updating Ads

reload()

An existing ad block can be reloaded using window.uAd.reload().

Syntax:

window.uAd.reload("adup1");

This uses the same parameters as the original embed() call.

Important:

An ad block may be reloaded at most once every 10 seconds.

Each reload generates a new impression.

Example

setInterval(function () { window.uAd.reload("adup1");}, 30000);

This example reloads the ad block every 30 seconds.

Removing Ads

remove()

You can remove a previously integrated ad block using window.uAd.remove().

Syntax:

window.uAd.remove("adup1");

Example

setTimeout(function () { window.uAd.remove("adup1");}, 120000);

The ad block is removed after two minutes.

Overview of API Methods

Typical Applications

The Delivery API is particularly suitable for:

• Single Page Applications

• Infinite Scroll

• dynamically generated content

• personalized web pages

• complex publisher systems

Best Practises

Only load API once

The Delivery API should only be integrated once per page view.

Load asynchronously

Asynchronous integration improves performance and prevents blocking page loads.

Only update ads when necessary

Use reload() only when new ads actually need to be loaded.

A reload always generates a new impression.

Remove ads cleanly

If containers are deleted dynamically, remove() should also be called.

This ensures that memory and resources are cleaned up properly.

Name containers uniquely

Use a unique container ID for each ad block.

Example:

• adup-header

• adup-sidebar

• adup-footer

Common Error Sources

API integrated multiple times

The API must only be loaded once per page view.

Ads initialized before API

window.uAd.embed() must only be called after the API has fully loaded.

Reload executed too frequently

At least 10 seconds must elapse between two reloads.

Incorrect container ID

The HTML container must already exist before embed() is called.