Spark CDN is the first CDN built specifically for video delivery. Spark CDN is an overlay which sits on top of your existing CDN; it does not require any changes to your existing infrastructure. Spark CDN uses both client and server technologies to:
Spark CDN was built from the ground up to specifically handle video traffic.
Spark CDN is the only CDN able to perform
mid-stream switching, which means a single
video will be fetched from multiple servers.
Spark CDN "auctions" video segments between Spark CDN servers and the existing CDN(s). The first few segments are served by the fastest servers available, and subsequent segments are served by servers that may be located in other regions.
By fetching most segments from Spark low-cost CDN, Spark reduces costs while improving performance.
Spark CDN is composed of client-side and server-side components, as well as a portal for monitoring and configuration.
Spark CDN's user experience dashboard and MultiCDN manager and player are 100%
These elements enable you to measure and improve your video performance. We believe that until today, CDN providers avoided discussing video user experience, since it was not possible to measure it well, and therefore, not possible to improve it much.
Spark CDN's new tech makes dramatic improvement possible to all metrics, so we wish to put this discussion back on the table. You can then choose to use Spark CDN streaming servers, and only for traffic used, with no minimum commitments.
No. Spark CDN is based on a proprietary network of our own servers. We believe
that the ecosystem and technologies are not ripe for P2P video distribution.
Spark CDN does not use P2P or any P2P resource or upload bandwidth.
Spark's parent company, Hola, has a separate product division called 'Hola P2P VPN' and is otherwise unrelated.
Spark CDN does not use resources of the Hola P2P VPN network.
See the 'Starting to use Spark CDN' section.
Mid-stream switching is Spark CDN's ability to download video segments
from multiple servers or CDNs while a video is playing.
Spark CDN's mid-stream switching improves video start times, reduces buffering and improves video bitrates - simply because multiple sources are available, and the player can switch to the best available source at any given time. The decision on where to download the video segment from is done by the Spark CDN JS client. The client keeps track of the player's buffer, as well as download speeds of video segments from multiple servers. It also receives information about network speeds from the Spark CDN network. The decision is made in real time, for every video segment, and takes into account the user's link speed at the time of the decision.
Allowing individual clients to make decisions is a more granular way of making decisions, as opposed to a centralized server, and guarantees improved performance.
Before RAID storage controllers became common, customers needed to buy
extremely high-end systems in order to enjoy fast and redundant storage
systems. These systems were expensive because they used high-end SCSI
drives and often high speed interconnections.
The introduction of the RAID controller changed this reality significantly. With a simple, inexpensive RAID controller, customers could now connect multiple off-the-shelf inexpensive hard drives on which the content was duplicated. When the controller fetched data, it requested it from multiple low cost storage devices, and the first to provide data back was used. So while on average, each low cost storage device was slower and less reliable than a high-end system, aggregated together they provided higher reliability (due to duplication), faster speeds (because of the auction in which the first device to respond would be selected) and lower costs.
Just like with RAID, using low-cost elements did not come at the expense of performance. In fact, the opposite is true - performance is improved.
Spark CDN was built from the ground up to handle only video traffic,
and video is very different from web traffic. Spark CDN's client-server
architecture allows it to achieve video optimizations, which are
not possible with existing CDNs. The Spark CDN client is able to get
traffic from multiple low cost servers and combine it into video which
performs better than video that is coming from a single high performance
server. Spark CDN keeps its operational costs low by:
These methods might look unusual, when compared with traditional CDNs.
That's fine. Spark CDN is not just another CDN. It is a radically new
approach to video delivery.
See the analogy: why is Spark CDN a lot like a RAID controller?
Yes. Spark CDN latches on to your existing CDN infrastructure, making it faster, cheaper and more reliable, and enables you to get detailed QoE statistics and to use multiple CDNs to ensure further reliability and cost reductions.
Spark CDN works out of the box with your existing URLs and DNS settings. There is no need to change anything. The Spark CDN client code intercepts requests for video chunks from the player. It uses mid-stream switching to select the optimal server in real-time, and stream each chunk from that server.
Spark CDN pulls first copies of the video from your existing CDN, and not from your origin server. You may choose to configure Spark CDN to also be able to pull video from your origin, but this is not needed and rarely done.
Spark CDN was designed so that it will never overload your origin or existing CDN. Spark CDN uses multiple 'origin protection' mechanisms to ensure that your existing CDN will not incur significant overhead.
You may see HTTP 503 (service unavailable) errors in your developer console
when using Spark CDN. This behaviour is normal and expected.
Spark CDN uses mid-stream switching to stream video chunks from multiple servers while the video is playing. The algorithm makes real-time decisions, using information regarding the user's Internet connection, video quality, player buffer size and other factors.
In some cases, the algorithm may decide it is better to abort/cancel an HTTP request and issue a new request, for example to a different server. In these cases, the console may show aborted requests, but they have no negative impact on performance. You can safely ignore these errors.
Spark CDN's mid-stream switching technology enables
it to download video chunks from multiple servers. Every time a video chunk
is downloaded from a server, the Spark CDN client calculates its speed by using
the size of the video chunk, and the time it took to download that chunk.
This is effectively an ongoing 'speedtest', but one that does not add any
traffic or overhead. It allows Spark CDN to have real-time information regarding
individual server response times, factoring in server load, internet
connectivity to that specific server, etc. The Spark CDN system communicates
this server speed information to nearby clients so that they can anticipate
server speeds and make smarter selections.
It is easy to see this in action by using the demo on holaspark.com. Open the 'Detailed statistics' screen and note that every time a video chunk is downloaded from a server, that server's speed is updated.
The only time Spark CDN performs a speedtest that adds traffic is the first time it is used on your site, in order to improve video start times. See how Spark CDN improves video start time.
Throughput and video bitrates are not the same. It is possible to deliver a
high-bitrate video stream with different throughputs.
Spark CDN uses its fast start servers to ensure that the video starts fast, and to allow the player to create a 20-30 second buffer. This inherent buffer allows for many of the optimizations that Spark CDN provides.
Once the buffer is in place, as long as the time it takes to download a video segment is shorter than the video duration, the buffer will always be full, and there is no risk of buffering.
For example, if a 2Mbyte segment contains 10 seconds of video, it does not matter if this segment is fetched in 300msec (high throughput), or in 900msec (slower throughput), because every segment delivered is 10 seconds long. The buffer will not be compromised.
Video on Spark CDN is delivered from multiple servers. Each server will have a different throughput. Spark CDN always selects the best server to deliver the video in a way which will maintain or improve video quality, reduce buffering and reduce costs.
For 20 years, CDNs have worked by connecting the user with the closest server to that user. This results in pretty good performance during off-peak hours, and mediocre performance during peak hours when the content is most needed. The reason for this is that many users in the same geographical area will try to connect to the same server(s) closest to them. Spark CDN solves this problem by splitting large MP4 video into segments (or, in the case of HLS/HDS, uses existing segments). Spark CDN then takes the first few segments from servers close by (for fast start times). All other segments are taken from servers in other geographical locations (for offloading and higher bandwidth). This improves the user experience of your videos, while reducing the costs, because of Spark CDN's better server utilization.
Fastly's architecture is similar to Akamai's, except that Fastly uses high end servers to provide faster service. Videos with Fastly should start faster and buffer less. In fact, Fastly is often too fast for video, which ironically only increases cost, but does not result in noticeable performance improvement. Spark CDN uses high end servers ONLY for the first few seconds, and fetches the rest of the video from low end servers in parallel, thus creating a fast start (like Fastly), but with low cost and high bandwidth for the remaining parts of the video.
Peer5, Streamroot and other P2P CDN solutions rely only on client technology and typically use the WebRTC protocol. They are subject to WebRTC/browser limitations, which results in low cache hit rates, especially for VoD traffic. Spark CDN uses client-side code working with server-side code. Spark CDN servers maintain persistent copies of the video files, thereby achieving extremely high cache hit ratio and higher level of effectiveness and performance.
Conviva is a user experience information system that gives publishers
insight into their users' experience, allowing them to choose
the best CDN according to specific criteria. Conviva uses historical data
reported by clients, and a centralized server is used for estimating
the best CDN. Conviva does not offer its own CDN, and does not offer free
Spark CDN provides a free user experience dashboard that provides detailed user experience metrics, allowing you to accurately measure performance of one or more CDNs.
Spark CDN offers a free MultiCDN solution, which uses real-time midstream switching between CDNs. Switching decisions are distributed, performed by each end-user device, using real-time information, every 100msec.
Spark CDN also provides the CDN streaming service, which is cheaper and provides higher performance than the traditional CDNs from which Conviva selects.
Cedexis measures performance of traditional CDNs and allows switching to
the optimal CDN. Cedexis helps customers select between two or more
traditional CDNs, and the selection process is done by consulting with a
Spark CDN allows mid-stream switching between multiple traditional CDNs and Spark CDN, which is a video-only CDN and offers improved performance at a reduced cost. Furthermore, in Spark CDN all switching decisions are made by a real-time client-side code, on a segment-based level, while taking into account all of the user's link characteristics and performance. This distributed decision making offers improved, more accurate performance.
No. You need to keep your existing CDN, for a few reasons.
Yes. You can read and/or modify Spark CDN configuration via API. The same API can also be used for enabling or disabling Spark CDN. See the step-by-step guide for syntax and instructions.
Yes. You can include the Spark CDN JS in embed code that you provide to 3rd party sites. You can also have separate statistics for each embedded JS. See the step-by-step guide for syntax and instructions.
Typically, when a video starts playing, if the first video segment arrives too
late or does not arrive at all, the video player may 'give up' and the video
will not play. When using a traditional CDN (which uses a single server for
the entire video stream), this can happen as a result of peak time load, or
downtime. Spark CDN can fetch video segments from multiple servers for a single
video stream. Video segments may be fetched from Spark CDN servers as well as
from your existing CDN.
If the first video segments fail to arrive on time from your existing CDN, the Spark CDN client will attempt to download them from one or more Spark CDN servers deployed worldwide. This increases the probability of the video starting, and reduces play failures.
Spark CDN fetches video segments from multiple servers for a single video
stream. Video segments can come from
Spark CDN Fast Start servers
as well as
selects the fastest available source, for the fastest possible video start
To decide which source is fastest, the Spark CDN client collects information from several sources. First, it uses historical measured download speeds from different servers that the client saved on the device. If there are no historical measurements, it uses similar information measured by other users in the area. And lastly, if no information is available, it downloads the first 64K of data from all potential sources, effectively performing a 'speedtest' among them, and downloads the first video segments from the fastest one. Start times with Spark CDN can be same or better than they are with the existing CDN. The same logic and methods are applied to improve seek times.
Videos buffer for different reasons. To see how Spark CDN reduces buffering, watch these short videos, or read the answer below:
Spark CDN can fetch video segments from multiple servers
for a single video stream. These segments can be fetched from Spark CDN
servers, as well as from your existing CDN. If one of the video sources
this and request video segments from other servers on the network before
any buffering occurs. If Spark CDN is not used, the entire video
is retrieved from a single existing CDN server, and if that server is
slow, end-users will experience buffering.
Spark CDN's ability to fetch video segments from multiple sources offers multiple levels of backup against buffering and reduces the probability of buffering for end-users.
It is impossible to eliminate buffering altogether, as some buffering can result from the end-users' slow last mile connections.
In traditional CDNs, when the selected video source is overloaded or slow,
buffering is prevented by gradually reducing the video bitrate, which
results in loss of quality.
Spark CDN's ability to fetch video segments from multiple sources by using mid-stream switching offers multiple levels of backup against reduced bitrates.
With Spark CDN, the average bitrates will be same or better than those without Spark CDN.
No. When a live stream is detected, Spark CDN fetches the live stream from
your existing CDN, by polling it every second. As a result, Spark CDN servers
have a copy of the live video 2-3 seconds after they appear on the original
Video players playing live video always maintain a buffer (typically 30-60 seconds) to prevent buffering in case of variations in bandwidth or server response times. This means that at the time live video becomes available on Spark CDN servers, video players are still playing video from the buffer.
By the time the buffer is depleted and new live segments are requested, these segments already reside on Spark CDN servers. As a result, live video segments from Spark CDN will be played at the exact same time as they would have if they were fetched from the existing CDN, with no additional delay.
Yes. All Spark CDN benefits apply to previously recorded live video that the user seeks back to when working in DVR mode.
Spark CDN was designed to work well with irregular traffic. Unlike
traditional CDNs which serve content from only one of a few servers
that are located close to the user, Spark CDN uses multiple servers
When a local traffic spike occurs (for example: a major news event causing a surge of live video traffic), traditional CDNs will quickly become loaded in the related regions, resulting in reduced bitrates and/or end-user buffering.
The process of a new server becoming an additional source for a video file or live stream is automatic and takes seconds. When demand for the video starts to decrease, the Spark CDN servers added for playing the video will gradually leave the pool of sources and become sources for other video URLs.
Essentially, the system automatically expands and shrinks dynamically as required.
If your viewers watch many different videos (long tail), they will hit
the local caching servers on a traditional CDN with requests for many
different files in a short period of time. The caching servers will serve
those files and cache them, but because each video is viewed infrequently,
the video file will be removed from the cache to support new file requests
coming in. The next requests for the files that were removed will cause
the caching servers to fetch them from the origin servers again. Because
this method of work causes load on the origin servers, which results in
slower video load times, it is often not economical to use traditional
CDNs for long tail content.
Spark CDN caches only the first few seconds of each video, by using servers located close to where the viewers are watching it, and while the main body of the video is cached in several servers around the world. This enables caching of much larger libraries of content close to the users for a fast start, and continuing from other servers on the Spark CDN network. This approach reduces cache misses and load on the origin server, and makes long tail video distribution a practical reality.
This is also enabled by the fact that whereas traditional CDNs use DNS redirection of entire domains to re-route to caching servers, Spark CDN caches video on a per URL level, allowing different videos to be fetched from different locations.
Video ads are an especially challenging type of video, and have not received
the right attention by CDNs. When ads fail to play or don't start fast enough,
more users will simply give up, never viewing the ad, resulting in lost
Users expect high performance video both for the ad and for the post-ad content which they intended to see in the first place. Spark CDN improves both pre-roll and mid-roll video ad performance using the following methods:
Spark CDN allows the publisher to improve video ad success rate and start time, by letting the publisher configure running the ads through the Spark CDN network (without needing to coordinate with the ad network), using the same technology used for accelerating other videos.
Because Spark CDN has a client side module, this module is used for preloading
the video content which the user wanted to watch in the first place while the
video ad is playing. As a result, the video will start as soon as the ad is
completed (or skipped).
Note that preloading of video is done only after the web page is fully loaded, so that page load time remains fast.
Yes. Spark CDN works with any kind of advertising inserted into the video
stream - MP4 preroll/midroll, and DAI (Dynamic Ad Insertion) type ads.
The Spark CDN control panel allows you to configure whether Spark CDN handles the video ads in addition to the video itself, or skips video ads altogether:
Similarly, in-stream advertisements are detected by Spark CDN client and can be
either transparently passed through to the original advertising server(s), or
optimized by Spark CDN.
In either case, your systems will continue to function just as they do without Spark CDN.
Yes, Spark can work with any existing CDN, origin server, or a combination of the two. If you are already using two or more CDNs, Spark CDN can still offload them and provide benefits.
<script>tag in the page displaying the video.
<script>to the page displaying the video.
Yes. See the monetization section for additional details.
Most implementations use a segment size of 10 seconds for HLS and 5 seconds for HDS. Because Spark CDN servers simply cache HTTP objects, Spark CDN works with any segment size. The client side algorithm automatically adjusts itself according to the segment size used in the specific stream. Some of our customers use segment sizes of 2-4 seconds.
Yes, Spark CDN can work with online video platforms, specifically:
Yes, Spark CDN can work with any live streaming platform. Specifically, Spark CDN offers transparent support for Nimble Streamer when using protected streams.
HTTPS video is supported; no special configuration is required. There is no need to upload HTTPS/SSL certificates to Spark CDN servers. Per GB price for Spark CDN streaming is identical for HTTP and for HTTPS.
No. Spark CDN is an overlay which sits on top of your existing CDN. It is not compatible with YouTube or DailyMotion embedded videos.
Some customers choose to change (typically reduce) default chunk sizes. This is typically done in order to accelerate video start time and to make the video more responsive while seeking. Reducing chunk sizes increases load on the video servers and CDNs.
For example, default HLS chunk sizes are 10 seconds, but some implementations go as low as 2 seconds. In any case, Spark CDN supports any chunk size.
Yes. Spark CDN supports all resolutions and formats, because it caches HTTP video segments. Spark CDN works well with any video segment size. Some of our customers are using 12-15MB HLS video segments with no issues.
Modern web browsers generally support HTML5 video, but not all of them use
the same decoding. Since video can be encoded in different ways, it may play
differently on different browsers.
To ensure optimal compatibility for all browsers, Spark CDN recommends using the following encoding settings:
No. Spark CDN only supports HTTP-based protocols.
Sign up at holaspark.com,
then follow the step-by-step guide, which is available in
If you want to test Spark CDN streaming, configure how much of the traffic of those pages you want to stream through Spark CDN. You will then be able to compare the performance of your existing CDN to the Spark CDN performance.
Step by step instructions are found on the Spark CDN GitHub page. Spark CDN can be fully implemented in 10-15 minutes.
Browsers have a "same-origin" protection that prevents web pages accessing
Modern sites provide their content from multiple domains, and thus need a protocol to allow controlling this protection.
Cross-Origin Resource Sharing (CORS) is a protocol created to assure using multiple resources on the same web page.
There are 2 possible reasons why you may need CORS configuration with Spark CDN:
Access-Control-Allow-Origin: [your video origin domain]).
See our CORS config page for details.
The need to configure CORS arises from the combination between the type of media player you are using and the type of video files it plays:
crossdomain.xmlis configured on the server side, containing a list of domains that are allowed to access the server's resources.
See our CORS config page for details.
Spark CDN recommends enabling CORS settings for optimal performance with
progressive video streaming. Spark CDN can still work if you are unable to
configure CORS, but there are differences in how the system will operate.
Spark CDN does not require CORS configuration for modern adaptive streaming protocols like HLS, HDS etc. Adaptive streaming offers many advantages over progressive streaming, and it might make sense to consider moving to adaptive protocols in general.
Spark CDN uses a 'pull' model. There is no need to upload (or 'push') any
content to Spark CDN servers.
Spark CDN servers fetch video from either your existing CDN or your origin server(s) as these video segments are first requested by users.
You can specify as many origin servers and/or CDNs as needed, as you can see in the screenshot below.
Spark CDN only caches video chunks. It does not handle manifest files
(e.g. M3U8/F4M/MPD). In many cases, token authentication is only applied to
the manifest file and not to video chunks. In this case, Spark CDN will work
with no additional configuration.
Thus, the following answer is only relevant if video chunks themselves are protected using tokens.
Spark CDN servers must be able to fetch the initial copy of video chunks from your servers or CDN in order to serve video to users. When video chunks are protected using tokens, Spark CDN can use a few methods in order to be able to fetch them, for example:
For additional details, visit the GitHub page.
Content stored on Spark CDN servers can be easily protected using referrer protection, time-limit, IP encoding or a combination of these methods. Contact us to discuss specific implementation.
Spark CDN will not change any geo-blocking policies that you have in place.
Only users in [country xyz] will be able to watch your videos.
Spark CDN servers must be able to fetch the initial copy of video chunks from your servers or CDN in order to serve video to users. If your content is geo-blocked, some Spark CDN servers might not be able to fetch video from your servers.
In order to allow Spark CDN servers access to geo-blocked content, simply whitelist the IP addresses of a few Spark CDN servers. The list of Spark CDN server IP addresses to whitelist can be found in your Spark CDN portal.
Spark CDN deploys thousands of servers in multiple locations around the globe,
but you need to whitelist only a few of them. The list of server IP addresses
to whitelist is available both on the
Spark CDN portal
and via API.
The list is updated every few weeks. Importantly, if your whitelist is not fully up to date, Spark CDN will continue working normally. Spark CDN support will detect your out-of-date whitelist and contact you. You can then update the list whenever convenient.
Yes. Spark CDN supports DRM via simple configuration - contact us to find the best solution for your specific needs.
No. When the Spark CDN servers cannot provide video segments, your video player
will simply fetch those segments from your existing CDN, just like it did
before Spark CDN was added, at the original cost and performance.
You can test this yourself by either using the demo extension on your website, or playing with the online demo - play a video, and disable the Spark CDN servers one by one. You will see that video continues to be downloaded, initially from other Spark CDN servers, then finally from the existing CDN, with no interruption. Thus, with Spark CDN, the overall reliability of your video delivery is same or better. Since it has a fallback option, Spark CDN is not a single point of failure
You can granularly configure when Spark CDN will be used. Simply define zones for different content groups within your Spark CDN dashboard. For each such zone you can configure when videos will stream from the Spark CDN network according to the following matchers:
This is by design, and has no effect on your end-user experience, your video
performance, or your analytics.
The blocked resources report aims to give you insights into which of your resources are blocked from Google's bots that index your site.
Spark CDN purposely does not give Google bots access to its servers, in order to avoid duplicate indexing of your content and which could harm SEO rankings of your site.
To remove these warnings from your reports, filter out "player.h-cdn.com" from the blocked resources report in your Google Webmaster Tools/Google Search Console.
Yes. You can instantly purge videos from Spark CDN by specifying the offending
video URL using the control panel or via an HTTPS based API. You can also
block videos from being cached by using the same methods.
See the implementation guide for details.
In the developer console, enter hola_cdn.bug_report(). Copy the URL that was generated by the command and send it to Spark CDN support. This sends our support team the full information around the bug that you witnessed, for fast resolution.
web page. Users do not need to install any software or change any settings
is not the same as Java).
Users simply play the video, just as they do today.
generation of CDNs. This is similar to how YouTube and Netflix deliver their
The client-server approach enables the speed and cost efficiencies that Spark CDN provides. It also monitors the video being played, sending stats to the portal so that you can analyze your users' QoE.
the page load time. The JS size is between 150-200KB, depending on
required configuration. It is decompressed by the browser to around 750KB.
For best results, Spark CDN recommends to place the JS in the head section of the page, but this is not a requirement. It can also be placed at the end of the page.
The JS stays cached in the browser, so it is instantly loaded during repeat visits to the website, with no additional network traffic.
The algorithm and calculations are very light and do not cause a noticeable increase in CPU utilization or slow down the web page responsiveness in any way. Detailed information regarding load times and CPU utilization are available in the control panel.
See the GitHub page for details.
Spark CDN does not overwrite any native JS object methods. The JS adds 3 global variables to your page (hola_cdn, hola_player and hola_cdn_require). They are all prefixed. There is no pollution of the global scope.
Also, remember that by default, the JS loads in disabled mode, in order to protect from accidental mass-deployment. After you add it to the page, you can gradually enable it from the server side for a small percent of users to test, and increase the scope of deployment after you are comfortable with the results.
loading of the web page.
In rare cases your player will load and start playing the video before the Spark CDN JS is fully loaded. In such cases, the entire video will simply load from your existing CDN.
If Spark CDN's JS fails to load for any reason, your video will continue to work as usual, by loading in full from your existing CDN.
which in turn decides which CDN server to send each request to.
Upon receiving back video from the selected server, it sends that data back up to the player.
The client fetches the initial segments from the Spark fast start servers near
the client. Meanwhile, the client creates a hash from the URL, which
provides the client with a list of servers for fetching the next several
segments. These servers then provide the client with information about
other servers that hold the same content, so that more sources are
available to the client after the initial segments are playing.
If the client does not receive a response fast enough from Spark CDN servers, video starts being downloaded from the existing CDN. In parallel, Spark CDN continues to operate and once responses are received, it starts offloading traffic from the existing CDN.
In any case, Spark CDN is never a single point of failure.
Spark CDN works with both Flash and HTML5 video, but you should use HTML5 where available. Modern HTML5 players offer several advantages over legacy Flash based players:
You can use any HTML5 video player with Spark CDN. If you still use a legacy Flash based player and would like to upgrade to a modern HTML5 video player, check out the free Spark Player.
Spark CDN uses dedicated leased servers in hosting locations worldwide. Spark CDN has two types of servers on its network:
Spark CDN Fast Servers are used to serve the first few seconds of the
These are expensive high-end servers, connected via guaranteed high speed bandwidth. In fact, Fast Start servers offer higher performance, and are more expensive than traditional CDN servers. Spark CDN can afford these expensive servers because only the first few seconds of each video are fetched from them, which represents a very small fraction of the overall traffic.
Once the video is playing, the client-side JS will start downloading video segments from other, low cost servers on the Spark CDN network. This hybrid approach is unique to Spark CDN and offers the best of both worlds: Fast start times, and low overall delivery cost.
Spark CDN low cost servers, also known as cache servers, are cost effective
servers Spark deploys around the globe in cost effective locations.
The low cost servers are the main servers used to cache your videos and reduce your CDN cost. The reason Spark CDN can use low-cost servers while actually improving your video user experience and reduce your costs is because of the mid-stream switching technology which allows redundancy, similar to inexpensive hard-drives connected to a RAID controller that create an overall faster and more reliable storage solution. See the analogy: why is Spark CDN a lot like a RAID controller?
Spark CDN deploys thousands of servers in multiple locations. Unlike a traditional CDN, the distance of Spark's CDN server from your users is not important, because the initial seconds of the video are fetched from Spark CDN fast start servers close to your users, and the rest from our various PoPs around the world. See the analogy: why is Spark CDN a lot like a RAID controller? In any case, Spark CDN will always use your existing CDN as a fallback and it can only improve performance and reduce costs.
Spark CDN currently does not have servers inside China. However, Spark CDN can still reduce costs and improve performance for users inside China. This is because unlike a traditional CDN, the distance of Spark's CDN server from your users is not important. The initial seconds of the video are fetched from a server that is close to your users - most likely from the existing Chinese CDN, and the rest from our various PoPs around the world. See the analogy: why is Spark CDN a lot like a RAID controller? In any case, Spark CDN will always use your existing CDN as a fallback and it can only improve performance and reduce costs.
Spark CDN deploys thousands of servers in multiple locations around the globe.
Unlike a traditional CDN, the distance of Spark's CDN server from your users
is not important, because the initial seconds of the video are fetched from
Spark CDN fast start servers close to your users, and the rest from our various
PoPs around the world.
As a result, when your sites uses Spark CDN, it is effectively connected to global capacity, and not only to capacity offered by servers in your country. Thus, Spark CDN offers greater capacity than traditional, local CDNs.
See the analogy: why is Spark CDN a lot like a RAID controller? In any case, Spark CDN will always use your existing CDN as a fallback.
The Spark CDN client constantly monitors the speed and availability of the Spark CDN servers. If the performance of the Spark CDN server being used to stream the video is not fast enough for a steady stream, the Spark CDN client will instantly switch to another server (using Spark's mid-stream switching technology), with the following logic:
In any case, Spark CDN can only improve the reliability of your video delivery. Videos will stream without interruption - either from one or more Spark CDN servers, or from your existing CDN.
No. You do not have to upload content to Spark CDN to 'warm the cache'.
Spark CDN uses a 'pull' method to fetch the first copy of every video from your existing CDN.
The first user who watches a video is served from your existing CDN, and in parallel triggers Spark CDN to fetch a copy of the video from your existing CDN.
Spark CDN uses several methods to minimize the load on your existing CDN.
No. You do not need to pay for storage of your videos on Spark CDN.
While other companies charge monthly fees for similar products, we believe that the best way to show off the value of the Spark CDN is to first show what your existing performance is, and then to let you compare it with what we can do for you. Enjoy!
Sign up on holaspark.com, and you will receive an email with implementation instructions.
Yes. By default, Spark CDN team will enable Spark CDN servers to stream some
of your video traffic. This will reduce your existing CDN traffic and cost,
and it is free of charge.
You do not need to take any action to receive this traffic. If you are using Spark CDN video analytics and do not want to receive free traffic, contact us.
Spark CDN compares your native CDN's performance to the Spark CDN streaming performance. You can verify that Spark CDN's video analytics are correctly measured, by following these steps:
Spark CDN only collects information regarding video performance: start/seek
times, buffering events, video bitrates etc.
All statistics are available as tables and graphs per platform, per device, per country, per city, and per ISP and are exportable to multiple formats.
For a more detailed list see our reference guide.
No. Spark CDN does not collect any personally identifiable information such as
usernames and passwords. It only collects video performance information such
as start time, seek time, and buffering events.
Information collected is sent as clear text and can be seen in the browser developer console. Detailed sample printouts of the information collected are available in the reference guide. Data collected is stored on secure, dedicated Spark CDN servers.
If you want to reduce information collected even further, see below.
Yes. If you would not like IP address information to be stored on Spark CDN servers, you can simply turn on the "Enhanced user privacy" setting in the configuration section. This will strip away any user identifiers such as IP addresses from logs and error reports.
Yes, in order to see a live portal account, click 'live dashboard' on Spark CDN Video Analytics section of the website.
Yes. Additional users from the same company can easily be added to the same account. Contact Spark CDN support.
Spark CDN statistics are stored for each video in one second increments. Aggregation calculations are performed every 5 minutes. Raw data can be exported to JSON and CSV formats, and via API to external platform.
Yes. Detailed statistics are exportable as JSON events from the control panel via API. For even more granular data, raw data collected by Spark CDN JS clients can be uploaded into your databases.
Yes, this information can be retrieved from the raw data that you can upload into your databases.
Yes, you can use an API to download raw data over HTTPS. See the implementation guide for details.
If your account is active, Spark CDN does not delete video analytics from
your account, but the granularity of stored statistics varies.
Granular statistics (which go down to 5 minute intervals) are available for a period of 30 days.
Statistics 30 days or older are averaged (to hour, and later into days intervals).
So, last week's data includes all data points and the results are very detailed, but last month's data is less detailed.
Note:If your account is inactive for over 90 days (meaning: Spark CDN was not used to stream videos or collect video analytics), it will be automatically disabled. Billing records will remain intact, but all statistics in your account will be permanently deleted.
You may re-activate your account at any time by logging in to the portal.
Statistics for individual videos appear in the 'events' table as soon as the
video finishes playing.
Statistics from multiple videos are aggregated every 5 minutes, which is also the frequency the dashboard, maps and detailed statistics table are updated.
Yes. Alerts are available for key parameters and are sent via email.
the multiple CDNs you are currently using, and that's it! Spark CDN will
automatically measure performance of your different CDNs and select the
optimal CDN to use.
Note that Spark CDN only handles your video traffic. There is no need to change DNS settings or any of the other changes usually required when implementing multiple traditional CDNs. Spark CDN does not require you to make any changes to your existing CDN infrastructure.
Existing MultiCDN solutions:
In Contrast, Spark CDN:
Spark CDN's real-time, client based approach to MultiCDN provides more accurate results and delivers better performance.
MultiCDN switching is free. If you add Spark CDN as one of the CDNs to choose from, you will only pay for traffic coming from Spark CDN servers.
You do not have to use Spark CDN for traffic. You can use Multi-CDN switching on your existing CDNs. Spark CDN can be added as one of the CDNs via simple configuration on the portal.
No. Since Spark CDN uses a 'pull' model to fetch the first copy from your existing CDN, you do not need to change any of your publishing workflows or procedures.
MultiCDN switching has 3 modes of operation:
Yes, you can easily compare performance of multiple CDNs as part of the free statistics.
A detailed step by step description of the MultiCDN algorithm is available here.
Spark Player is based on VideoJS, an open source video player which is used by over 400,000 sites worldwide. Spark engineers have added several improvements on top of the base VideoJS code, which provide the following advantages:
Yes. If you are interested in upgrading your old player, we suggest you to
use the free Spark video player.
It is a modern HTML5 player which is fully open source and customizable.
The Spark video player is optimized to work with Spark CDN, but you can keep using it as a standalone player with any CDN if you choose.
No. You can continue to use your own player. Spark Player is totally optional.
Spark Player supports VAST and Google IMA based ads, including pre-roll, mid-roll and post-roll video ads. Documentation and sample code are available in the GitHub page.
Spark Player is based on VideoJS, an open source HTML5 video player. Find more details on the Spark Player GitHub page.
Yes. Find more details on the Spark Player GitHub page.
Yes. It is available in the plugin directory - you can find it
The Spark Player plugin for WordPress is free for commercial and non-commercial use.
The bandwidth saver is provided for free as part of Spark CDN. In fact, since it reduces total bandwidth consumption, it actually reduces the effective price of Spark CDN.
The bandwidth saver supports only progressive download of MP4/FLV/WebM video
The bandwidth saver does not work with segmented protocols such as HLS/HDS/DASH - these protocols have built-in mechanisms to save bandwidth.
The bandwidth saver prevents excessive downloading of video which might not be viewed by the user. It requests large video files in small segments and reduces bandwidth usage by 30-40%.
Spark CDN provides you with a free video analytics portal, detailed insights, reports and quality of service metrics to track, measure and monitor your streams. You can see your bandwidth savings in the portal - see the example below.
Typically, between 30-40%. Results will differ based on the duration of your videos, viewing habits, connection speeds, players etc.
See the list of compatible players.
A lot! The exact percentage depends on how much you are paying to your
existing CDN provider today. Our pricing is simple and transparent, with no
minimums or commitments. As a rule of thumb, expect Spark CDN to offload
90% or more of your video traffic from your existing CDN. This means that if
your existing CDN costs more than 1 cent/GB in any geography, any traffic
offloaded to Spark CDN will save you the difference.
In addition to a low per-GB price, Spark CDN also reduces the actual bandwidth consumption, see below.
Yes. Spark CDN reduces your traffic consumption using different algorithms.
Video players are implemented using different sizes, according to the design
of the web page. When the user watches video on a player with small
window size (e.g 400*300 pixels), there is no point in streaming very
high-resolution video (e.g. 1920*1080 pixels). This is because the large
video is simply reduced back to fit the small player size, which loads the
CPU, but offers no visible quality improvement. Furthermore, streaming
high-quality video increases cost and likelihood of performance issues
such as buffering.
The Spark CDN client side code optimizes video for the best viewing experience, without compromising quality. The user always gets the highest resolution viewable on their player.
The algorithm works as follows: Depending on available bandwidth, it selects video resolutions that are either smaller or slightly bigger of the target player resolution. For example, when playing the video on a small player (400x300 pixels), it will choose the closest resolution available (e.g. 480*320) but not higher resolutions. If the user switches to full-screen, the Spark CDN client will detect this and change the maximum resolution to 1920*1080, for example.
In any case, the Spark CDN client will never select a video bitrate that is higher than 1.2x the currently available bandwidth - this is to avoid buffering due to insufficient bandwidth.
Spark CDN uses as "Pay As You Go" model with a flat price of 1¢ per GB. You only pay for bytes downloaded from Spark CDN. There is no setup fee, no minimum commitment and no binding contract. Spark CDN is significantly more affordable than traditional CDNs, while providing better performance.
No. Spark CDN only charges for traffic flowing from Spark CDN servers to your users.
No. Spark CDN only charges for traffic flowing from Spark CDN servers to your users.
No. Spark CDN uses a technology that is radically different compared to traditional CDNs. Video on Spark CDN can be served from any country to any country. As a result, Spark CDN is priced the same for all countries.
Spark CDN offers a 7-day trial period that allows you to send unlimited
traffic, and you don't even need a credit card to get started.
You only need to go to holaspark.com and click the "Start Now" button, to open the dialog box used for signing up. After you fill-in your email address and password and click "Create account", a verification email is sent to the address you specified. Clicking the link contained in this message directs you to your Spark CDN account control panel, where your customer ID is displayed on the upper left corner.
During the evaluation period, video analytics are collected for all platforms, but Spark CDN traffic can only be enabled on Chrome browsers.
The 7-day period only begins on the day you start using Spark CDN to send traffic to your users.
At the end of the 7-day period, you may either activate your account by entering payment details, or continue using free features such as video, QoE statistics, and MultiCDN.
Spark CDN uses a simple prepayment model, similar to services like SkypeOut.
To purchase traffic on Spark CDN, visit your account page and buy bandwidth
The minimum payment for Spark CDN is $100.
An invoice will be sent to your account's email address.
With every 1GB traffic used, your account credit will be reduced by 1¢. Once your credit level drops below 15% of your balance, a notification will be sent, reminding you to add bandwidth credits to your account.
When your balance reaches zero, Spark CDN servers will no longer send traffic to your users. All video will be downloaded from your original video source(s). Statistics collection will continue, because statistics are free.
Credits in your account do not expire, and any unused credits are rolled over to the next month.
Spark CDN accepts credit cards, PayPal and wire transfers.
Yes. Enter your costs in the control panel, and Spark CDN will only kick-in if your existing CDN underperforms. Spark CDN will monitor the health of the video stream in real-time, and if there is risk of buffering, it will be activated, ensuring that end-user performance remains acceptable. You will only be billed for traffic sent by Spark CDN servers during these periods, with no minimum or commitment. See the screenshot below:
You can enjoy the benefits of Spark CDN even if you have a pre-commitment
with your existing CDN. Configure Spark CDN to be more expensive than your
CDN, even if it is not. User experience statistics are 100% free; and
Spark CDN can kick in automatically as performance booster when your existing
CDN performs poorly.
You can tune Spark CDN so that your pre-committed traffic will be used in full, and any traffic over the precommit will be handled by Spark CDN at reduced rates. As you exceed your precommit level, change the cost back so that Spark CDN is cheaper than your CDN, and Spark CDN will start offloading traffic.
Once the pre-commitment period is up, many customers significantly reduce the pre-commitment to the existing CDN, which allows them to extend their savings and performance improvements.
Spark CDN offers support via mail, WhatsApp, phone and Skype. In addition, customers have access to 24x7 support, which is provided by Spark engineers manning our Network Operations Center (NOC).
Spark CDN operates a 24x7 Network Operations Center (NOC), monitored by Spark engineers. The NOC team uses automated systems to monitor your site's health, and is trained to perform manual tests to identify and troubleshoot problems. Monitoring is performed on three levels:
Spark CDN customers enjoy 24x7 monitoring of their sites. Videos on your site undergo comprehensive automated testing every 15 minutes as follows:
If one of the tests fails, the NOC team receives an automated alert and will
check the nature of reported problem. If you opted to use the
Hotline service, the team will alert you
with a detailed description of the issue by phone and/or email.
For example, Spark CDN NOC might notify you that on a specific part of your site, video ads are not loading, or that videos freeze after 10 seconds when playing on Android.
Coming soon: Current and historical site test results will be available on your Spark CDN control panel, and you will receive automated alerts if one or more of the tests fail.
Yes. Spark CDN offers a "Hotline" service, which allows you to be notified in
case of problems on your site or on your existing CDN.
You can receive alerts via phone or email. To enter your contact details and specify times of day Spark CDN is allowed to contact you, go to your portal account and enter the relevant information.
Spark CDN support team focuses on video related issues. The Hotline service is offered as a courtesy and should not be used as a replacement to full site monitoring.
The Hotline service is provided free of charge to Spark CDN customers.
Spark CDN is an overlay to your existing CDN. It offloads video whenever
possible in order to reduce costs and improve performance. In case Spark CDN
is slow or unavailable for any reason, traffic will simply be reverted to
your existing CDN. Spark CDN is never a single point of failure.
You can test this yourself by playing with the online demo. Play the video, and proceed to disable all the Spark CDN servers. You will see that video continues to be downloaded, from the existing original CDN (in red), with no interruption.
In addition to the built-in failover mechanisms, Spark CDN performs 24x7 monitoring to check the health of your site.
Thus, with Spark CDN, the overall reliability of your video delivery and of your site in general is same or better than without Spark CDN.
As a result, Spark CDN does not offer an SLA, but is provided as an 'as-is' service. You can see additional details in the license agreement.
The cancellation terms are as defined in the
Spark CDN service is provided as-is. There are no refunds.
Some companies use 3rd party security firewalls or proxies which are
designed to block access to domains that fall into certain categories
(e.g. adult content, gambling). In some cases, these 3rd party solutions
incorrectly categorize legitimate sites and block them. The security
industry calls these cases 'False Positives' and actively tries to eliminate
them, as they harm, rather than help, their customers.
If holaspark.com works normally from locations other than your office, it is possible that holaspark.com is categorized incorrectly by your company's security solution and as such is a false positive.
In this case, please contact us with the name of the offending firewall. Spark CDN support will contact the vendor and remove the false positive. Your security device will receive an automatic update from the security vendor and the block will disappear. This process usually takes a few days.
Note that such false positives only impact your ability to browse to holaspark.com. They do not impact the functionality of Spark CDN's ongoing service in any way.
The Spark CDN demo Chrome extension is a tool that can be used for
demonstrating Spark CDN in action on an existing website, with no
The demo extension is not guaranteed to work on all websites or videos. It is possible, for example, that the extension will fail to find the video player on the page, or that the video player included in the page is not supported.
You should also be aware that the extension demonstrates the performance of a "cold cache" system, namely: a system where the requested video was not yet saved to cache and is being played by using a physical read from the disk. This is because you, as the extension user, are the first and only user of the video on your website page! As a result, the performance you witness is far from the one provided by a "warm cache" system, where videos are pre-cached on multiple servers.
Therefore, the Spark CDN demo Chrome extension should only be used for demonstrating Spark CDN's seamless integration and ease of use, and not for performance purposes. With that in mind, you are welcome to download the demo extension here.
Go to a web page with video. Play the video, and then click the Spark CDN
extension button. You will see that the code is being injected into
the web page. When the process is complete, press play and Spark CDN
should work. Note: Sometimes, you may need to pause the original video
before clicking the Spark CDN extension in order to avoid 2 videos
playing at the same time. Also, in case the extension cannot replace
the video player in the exact location, it will open as a floating
frame on top of the web page. This is normal.
The extension is updated automatically every time a new version becomes available on the Chrome store.
The Detailed Statistics screen provides additional information that can
help demonstrate how Spark CDN works. It contains the list of active servers
for the current video, as well as their location, throughput, and latency.
The video player buffer is also shown. All statistics are updated in real
Look at the player buffer as it goes up and down. You will see that it usually remains above 15 seconds. This 'safe zone' allows Spark CDN servers which are *not* the fastest and do *not* have the best latency to deliver video without harming user experience.
Experiment with the switches; Disable the active Spark CDN server, and see how traffic is shifted to other Spark CDN servers.
Disable all Spark CDN servers, and see the graceful fallback to the original CDN. This will show you how Spark CDN is not a single point of failure.
Lastly, experiment with disabling your own CDN server. You will see that video will continue playing from different Spark CDN servers. This shows how Spark CDN can actually increase the overall reliability of your system; if one of your servers or CDN underperforms or goes down, Spark CDN will ensure video continues streaming.
The cost savings calculator provides a quick estimate of the cost savings
that Spark CDN can deliver. Enter your cost per GB in the box, making sure
that you entered the blended worldwide costs. As the video starts playing,
you will see the estimated savings.
Note that the savings calculator is only able to provide an estimate. Your actual results will vary. For example, if your typical video duration is longer than the video you are using with the demo extension, your savings will be considerably higher. As a rule of thumb, expect Spark CDN to offload 90% or more of your video traffic from your existing CDN.
Send an email to firstname.lastname@example.org with the exact URL where you tried the extension and a few words about the problem you saw. An engineer will try to fix the problem and inform you when the fix is available. Note: it is possible that the extension will not be able to work on some sites.
The Spark CDN extension is a quick way to see the benefits of Spark CDN on your site, but it does not fully replicate a complete Spark CDN integration. The 'Simulation mode' alert means the video played is protected using a method which prevents Spark CDN servers from downloading the first copy of the video in order to serve it to users. To see a real simulation of Spark CDN using the extension, try another video on your site which is not protected. For example, videos of full episodes are often protected, but short clips/trailers are not. Content protection is easy to handle when doing a full Spark CDN deployment. For additional information visit the GitHub page.
The Spark CDN integration wizard is a tool that can be used for testing a web page with Spark CDN and to present its test results.
Go to the integration wizard, paste your URL web page, click on the test button, and verify the results.