epubear.scand.com

The standard epuBear SDK ships with a defined feature set that becomes available immediately upon purchase, but several capabilities fall outside that scope and require custom development. Based on the vendor's own description, full or particular EPUB 3 support, DRM integration, and other custom features are not part of the standard package — they are delivered by the epuBear development team as custom solutions with ongoing support. If your product roadmap depends on any of these, plan for a custom engagement rather than assuming the base SDK covers them.

What the standard SDK does include

To judge what's missing, it helps to know what you get out of the box. According to the product page, the following are available immediately upon purchase:

• EPUB 2 and EPUB 3 compatibility
• Reading EPUB files from file storage or loaded into memory
• Extracting EPUB document information
• Rendering pages to bitmap images
• Multiple languages, including vertical and right-to-left writing
• Navigation features
• Customizable reading experience
• Bookmark management
• Text search
• Text selection (highlight and underline)
• Text notes
• Text-to-Speech support
• Audio and video playback within EPUB content
• Opening and zooming pictures within EPUB content

The SDK is described as a closed-source cross-platform core with wrappers for Kotlin (Android), Swift (iOS), C# (MAUI), and Dart (Flutter).

Features that require custom work

Full or particular EPUB 3 support

The page lists "EPUB 2 and EPUB 3 compatibility" as a standard feature, yet also names "full or particular EPUB 3 support" as an example of additional functionality requiring custom delivery. The practical reading: baseline EPUB 3 compatibility is included, but if your content relies on specific EPUB 3 capabilities beyond that baseline, treat it as a customization request and confirm coverage with the vendor before committing.

DRM integration

DRM integration is explicitly listed as a custom feature, not a standard one. If you distribute protected content — for example, a subscription reading app that must honor a publisher's rights-management scheme — you cannot assume the base SDK handles it. This is a scoping and licensing conversation, not a configuration toggle.

Other custom features

The vendor states that "any other custom features" can be delivered by its development team, with ongoing support. That's an open-ended category, so the useful move is to map your requirements against the standard list above and route anything unmatched into a custom-scope discussion.

How to decide

If your needs sit entirely within the standard feature list, the base SDK is the straightforward path. If any requirement touches DRM, advanced EPUB 3 behavior, or something not listed, start a scoping conversation early — these affect architecture, timeline, and cost, and the page does not publish pricing or terms for custom work.

If you're new to Ahrefs and want to run your first SEO audit, the fastest path is: open Site Explorer, enter your target URL, review the Overview for a health snapshot, then dig into Organic Keywords, Top Pages, and Site Audit to find specific problems. From there, build a short prioritized to-do list instead of trying to fix everything at once.

This tutorial walks through that workflow using a realistic starting scenario, explains what the numbers mean, and shows how to turn findings into actions.

Before You Start: Pick a Narrow Scope

A common beginner mistake is auditing an entire large website on day one. The reports become overwhelming, and you can't tell which issues matter.

Instead, choose one of these starting points:

• A single important page (your homepage or a key product/service page)
• A small site (under ~50 pages, e.g., a personal blog or small business site)
• One section of a bigger site (e.g., /blog/)

For this tutorial, assume you're auditing a small business site with about 30 pages. The same steps scale up later.

You'll need an Ahrefs account to follow along. Ahrefs offers paid plans, and pricing and feature limits change over time, so check the current Pricing page for what's included in each tier before committing.

Step 1: Enter Your Target in Site Explorer

Site Explorer is Ahrefs' core tool for analyzing any website or URL.

1. Open Site Explorer from the top navigation.
2. In the search box, paste your domain (e.g., example.com).
3. Choose the Exact URL or Domain mode depending on scope. For a full-site view, use Domain or Prefix; for a single page, use Exact URL.
4. Press Enter.

You'll land on the Overview report. Don't try to absorb everything — focus on four numbers first.

Reading the Overview Snapshot

Important caveat: Ahrefs' traffic and keyword numbers are estimates based on its own data. They won't match Google Search Console or your analytics exactly. Treat them as directional, not absolute.

Step 2: See What You Already Rank For

Go to Organic Keywords in the left sidebar. This shows queries where your site appears in search results.

Sort by Traffic (descending) to see which pages bring the most estimated visitors. Then look for:

• Keywords ranking in positions 4–15 — these are often the easiest wins. A small content or on-page improvement can push them onto page one.
• Keywords with high volume but low position — potential opportunities if the topic is relevant.
• Irrelevant keywords — if you rank for something off-topic, it may signal thin or mismatched content.

Write down 5–10 of the position 4–15 keywords. These become your first optimization targets.

Step 3: Find Your Best and Weakest Pages

Open Top Pages. This ranks your URLs by estimated organic traffic.

Look for two things:

1. Your top performers — understand what topics and formats work. Can you create more content like this?
2. Pages with traffic but poor rankings — these may need on-page fixes (title, headings, internal links).

If a page gets zero traffic and targets a topic you care about, it's a candidate for a rewrite or consolidation.

Step 4: Run a Technical Site Audit

Now move to Site Audit. This crawls your site and flags technical and on-page issues.

1. Click Site Audit → New project.
2. Enter your domain and set crawl settings (default is usually fine for a small site).
3. Start the crawl and wait for it to finish.

Once complete, you'll see a Health Score and a list of issues grouped by category.

Which Issues to Fix First

Not all issues are equal. Prioritize in this order:

Ignore low-impact warnings (like minor meta description length) until the big items are handled.

Step 5: Turn Findings Into a To-Do List

You now have raw data. Convert it into a short, actionable list. Example:

1. Fix 3 broken links found in Site Audit.
2. Rewrite title tags on 5 pages with duplicate titles.
3. Improve 4 pages ranking in positions 6–12 by adding missing subtopics and internal links.
4. Remove or update 2 thin pages with no traffic.

Keep the list to 5–10 items max for your first audit. Finishing a short list beats starting a long one.

Common Beginner Mistakes

• Chasing every red flag. Site Audit flags many minor issues. Fix what affects rankings and users first.
• Trusting estimates as exact numbers. Ahrefs data is modeled, not measured from your analytics.
• Auditing a huge site too early. Start small to learn the interface.
• Ignoring search intent. A page can be technically perfect but still fail if it doesn't match what searchers want.
• Forgetting to re-crawl. After fixes, run Site Audit again to confirm improvements.

Where to Go Next

Once your first audit is done:

• Compare with competitors using Site Explorer's Competing Domains and Content Gap reports.
• Track keyword rankings over time with Rank Tracker.
• Explore backlink opportunities in the Backlinks and Link Intersect reports.
• Set up recurring Site Audit crawls so new issues surface automatically.

Your first audit isn't about perfection — it's about building a repeatable habit: enter a target, read the key reports, pick the highest-impact fixes, and act. Do that once a month and your site's health compounds.

epuBear ships with a full reading feature set enabled at purchase: EPUB 2/3 parsing, page rendering, navigation, bookmarks, search, text selection and notes, TTS, and in-book audio/video and image handling. It is a closed-source cross-platform core with wrappers for Kotlin (Android), Swift (iOS), C# (MAUI), and Dart (Flutter), so the same feature set is reachable from native and cross-platform projects on Windows, macOS, Linux, iOS, and Android. If your product needs DRM, full or partial EPUB 3 coverage beyond the built-in level, or other custom behavior, that falls outside the standard package and is handled as custom development.

Core reading and format features

• EPUB 2 and EPUB 3 compatibility — both format generations are supported by the core.
• Flexible content loading — read EPUB files directly from file storage, or load them into memory.
• Document information extraction — pull metadata and structural information out of an EPUB document.
• Page rendering to bitmap images — pages can be rendered as bitmaps, which is useful when you need your own display layer or thumbnails.
• Offline support — reading works without a network connection.
• Lightweight, customizable core — the SDK is described as lightweight and highly flexible, intended to be embedded in an existing product rather than used as a standalone app.

Reading experience and interaction

• Navigation features — move through the book structure.
• Customizable reading experience — appearance and typography are adjustable; the Android sample shows an appearance mode setter and a font size setter.
• Bookmark management — create and manage bookmarks.
• Text search — search within the content.
• Text selection with highlight and underline — select text and apply highlight or underline styling.
• Text notes — attach notes to text.
• Night mode — listed among the reader capabilities.

Multilingual and media features

• Multiple languages, including vertical and right-to-left writing — relevant if you publish Japanese-style vertical text or Arabic/Hebrew RTL content.
• Text-to-Speech — built-in TTS for reading content aloud.
• Audio and video playback inside EPUB content — media embedded in the book can be played.
• Open and zoom pictures inside EPUB content — inline images can be opened and scaled.

Platform and integration surface

The Android initialization example shows the shape of integration: build an EpubearConfig with your company name, app name, license key, and app files directory, then construct EpubearSdk and register listeners for events and CFI (reading position), followed by appearance and font settings. The iOS example begins by resolving a caches directory, indicating the SDK expects a writable storage location for its data.

What is not included by default

The feature list above is what is available immediately upon purchase. The following are explicitly named as custom work rather than standard features:

• Full or particular EPUB 3 support beyond the built-in level
• DRM integration
• Any other custom functionality

For those, the vendor's development team provides custom solutions and ongoing support.

How to decide

If your requirement is a standard EPUB reader embedded in an app — reading, navigation, bookmarks, search, annotations, TTS, and embedded media — the out-of-the-box set covers it, and the wrapper for your stack (Kotlin, Swift, C#, or Dart) determines integration effort. If your roadmap depends on DRM-protected catalogs or specific EPUB 3 features not in the list above, treat those as a separate scoped project rather than assuming they are included.

epuBear supports desktop (Windows, macOS, Linux) and mobile (iOS, Android) targets, with official wrappers for Kotlin (Android), Swift (iOS), C# (MAUI), and Dart (Flutter). If your project is built in one of those four languages or frameworks, you can integrate the SDK directly. If you are working in another stack, epuBear does not list a wrapper for it.

How the architecture works

epuBear is not a single library you drop into every project. It consists of two layers:

• A closed-source cross-platform core that handles the actual EPUB parsing, rendering, and reading logic.
• A set of wrappers that expose interfaces for calling that core from native or cross-platform projects.

This means the platform coverage comes in two dimensions: the operating systems the core runs on, and the languages/frameworks the wrappers are written for. You need both to line up with your project.

Platform and framework matrix

The desktop operating systems (Windows, macOS, Linux) are listed as supported targets, and MAUI is the C# wrapper named for that path. Flutter's Dart wrapper covers cross-platform projects. Android and iOS each have their own native wrapper.

What integration looks like

You initialize the SDK inside your chosen language, then call its functions from your app code. The site provides initialization examples for Android and iOS.

Android (Kotlin):

val config = EpubearConfig(companyName, appName, licenseKey, ApplicationProvider.getAppContext().filesDir)
epubear = EpubearSdk(ApplicationProvider.getAppContext(), config).apply {
    setEventListener(this)
    setCfiListener(this)
    setAppearanceMode(EpubearSdk.EPUBAppearanceMode.EPUBAppearanceModeNormal)
    setFontSize(0, false)
}

iOS (Swift): the example begins by resolving the caches directory:

guard let cachesDirectory = FileManager.default.urls(
    for: .cachesDirectory,
    in: .userDomainMask
).first

The pattern is the same across wrappers: construct a config object (including a license key and a storage directory), instantiate the SDK, then attach listeners and set reading options. The input is your app context plus configuration; the action is SDK initialization; the expected result is a live reader instance you can drive from your UI.

Choosing based on your stack

• Native Android app → use the Kotlin wrapper.
• Native iOS app → use the Swift wrapper.
• .NET / MAUI app targeting desktop → use the C# wrapper for Windows, macOS, or Linux.
• Flutter app targeting mobile or desktop → use the Dart wrapper.

If your project uses a language or framework outside this list, the published wrappers do not cover it. The site notes that custom solutions are available from its development team for additional functionality, so an unsupported stack is a conversation to have with the vendor rather than something you can assume works out of the box.

What you get once integrated

The core feature set — available immediately upon purchase — includes EPUB 2 and EPUB 3 compatibility, reading from file storage or memory, document info extraction, page rendering to bitmaps, multi-language support (including vertical and right-to-left writing), navigation, bookmarks, text search, selection (highlight/underline), notes, text-to-speech, audio/video playback inside EPUB content, and image open/zoom.

Features beyond this set — such as full or particular EPUB 3 support, DRM integration, or other custom work — are handled as custom development, not part of the standard package.

epuBear is a closed-source, cross-platform EPUB reader SDK. You integrate it by adding the wrapper that matches your development environment — Kotlin (Android), Swift (iOS), C# (MAUI), or Dart (Flutter) — then constructing an SDK instance with a config object that carries your company name, app name, license key, and a writable files directory. The steps below cover the Android and iOS initialization paths shown in the official documentation, plus the basic calls you make right after init.

What the SDK is made of

epuBear ships as two layers:

• A closed-source cross-platform core that does the actual EPUB parsing and rendering.
• Language wrappers that expose that core to your project. The documented wrappers are Kotlin (Android), Swift (iOS), C# (MAUI), and Dart (Flutter).

Because the core is shared, the same feature set is available regardless of which wrapper you pick. The documented capabilities include EPUB 2 and EPUB 3 compatibility, reading files from storage or memory, extracting document information, rendering pages to bitmaps, multi-language support (including vertical and right-to-left writing), navigation, bookmarks, text search, selection with highlight/underline, notes, text-to-speech, audio/video playback inside EPUB content, and opening/zooming images.

Prerequisites

Before you write any code, confirm you have:

1. A license key. The config object requires one, and the documentation states the full feature set is available upon purchase. Pricing terms are not published on the page, so treat licensing as a commercial step you complete before integration.
2. A writable directory on the device for the SDK to use (the examples use the app's cache or files directory).
3. The wrapper package for your platform added to your project.

Initialize on Android (Kotlin)

The documented pattern is to build an EpubearConfig, then construct EpubearSdk with it, then attach listeners and set display options.

val config = EpubearConfig(
    companyName,
    appName,
    licenseKey,
    ApplicationProvider.getAppContext().filesDir
)
epubear = EpubearSdk(ApplicationProvider.getAppContext(), config).apply {
    setEventListener(this)
    setCfiListener(this)
    setAppearanceMode(EpubearSdk.EPUBAppearanceMode.EPUBAppearanceModeNormal)
    setFontSize(0, false)
}

What each part does:

• EpubearConfig(companyName, appName, licenseKey, filesDir) — identifies your app to the SDK and gives it a storage location. The fourth argument is the files directory from the application context.
• EpubearSdk(context, config) — creates the reader instance.
• setEventListener(this) — routes SDK events (for example, reading progress or state changes) to your listener.
• setCfiListener(this) — subscribes to CFI (canonical fragment identifier) updates, which is how you track and restore reading position.
• setAppearanceMode(...) — sets the reading theme; the example uses the normal appearance mode.
• setFontSize(0, false) — sets the text size. The two arguments let you pass a size and a flag; the example uses 0 and false as the starting values.

Initialize on iOS (Swift)

The iOS example begins by resolving a caches directory, which is the equivalent of the Android files directory:

guard let cachesDirectory = FileManager.default.urls(
    for: .cachesDirectory,
    in: .userDomainMask
).first

Use that directory when constructing the iOS config, then create the SDK instance and apply the same categories of setup — event listener, CFI listener, appearance mode, and font size — through the Swift wrapper. The wrapper names differ from Kotlin, but the sequence is the same: resolve a writable directory, build the config with your company name, app name, and license key, instantiate the SDK, then attach listeners and set display options.

Verify the integration

After initialization, check these before building features on top:

• The SDK instance is non-null and was created without a license or config error.
• Listeners fire — open a sample EPUB and confirm your event and CFI callbacks receive data.
• Display options take effect — change the appearance mode or font size and confirm the rendered page updates.
• A file loads — the SDK reads EPUB files either directly from file storage or loaded into memory, so test both paths if your app uses both.

Common sticking points

• Missing or invalid license key. The config constructor requires it; initialization is where a bad key surfaces.
• Unwritable directory. Passing a path the app cannot write to will break caching and rendering. Use the app's own files or caches directory, as both examples do.
• Forgetting the listeners. Without setEventListener and setCfiListener, you get a reader that renders but does not report progress or position back to your app.
• Assuming extra features are included. The documented feature list is what ships on purchase. If you need full or particular EPUB 3 support, DRM integration, or other custom functionality, the documentation states these are handled as custom solutions by the development team rather than being part of the standard SDK.