Browser Extension Development Company

The browser extension development company that handles the store review, not just the code.

Browser extensions sit closer to the user than any other software you build. They watch the page, read the DOM, modify the experience, and stay one tab away from every workflow your users live in.
RaftLabs builds Chrome, Edge, Firefox, and Safari extensions for productivity tools, AI assistants, sales prospecting tools, dev tools, CRM integrations, and consumer utilities, with Manifest V3 architecture from day one and store submission handled end to end.

  • Chrome, Edge, Firefox, and Safari extensions built from a single Manifest V3 codebase

  • Manifest V3 architecture from day one, service workers and declarativeNetRequest, no V2 rewrites later

  • Chrome Web Store submission and review process handled end to end, including rejection appeals

  • AI assistant, productivity, and CRM-integrated extensions that live inside the workflows your users already use

0-delay insights Voice AI20k+ txns day one AI Automation1,062 users in 4 weeks Loyalty

The problem

Sound familiar?

  • Extension rejected by the Chrome Web Store review team and the rejection email reads like a riddle?

  • Internal team needs a browser extension to automate a workflow but nobody on the team has built one before?

Short answer

RaftLabs builds Chrome, Edge, Firefox, and Safari extensions on Manifest V3 for clients across the US, UK, Europe, Canada, and the UAE. Most launch a validated v1 in 6-12 weeks at a fixed price, and we handle Chrome Web Store submission end to end, including rejection appeals.

Key takeaways

  • Chrome, Edge, Firefox, and Safari extensions built from a single Manifest V3 codebase
  • Most launch a validated v1 in 6-12 weeks at a fixed price
  • Chrome Web Store submission handled end to end, including rejection appeals
  • LinkedIn prospecting extensions push contacts into HubSpot or Salesforce with one click and log activity automatically
  • AI writing-assistant extensions add a sidebar to Gmail, Google Docs, and Notion
  • Internal automation extensions remove repetitive multi-step data entry across your team's tools

Trusted by

Vodafone logo
Aldi logo
Nike logo
Microsoft logo
Heineken logo
Cisco logo
Calorgas logo
Energia Rewards logo
GE logo
Bank of America logo
T-Mobile logo
Valero logo
Techstars logo
East Ventures logo
TuneClub logo

The extension was done. Then the rejection email arrived.

A team builds the extension internally. It works in their own browser, does exactly what they need, and ships to the Chrome Web Store. Three days later the rejection email lands, citing a policy section by number, and nobody on the team can decode what it actually wants.

The code was never the hard part. The permission model, the single-purpose framing, and the privacy policy that has to match what the extension really does with data: that is what the review team reads, and that is where internal builds stall.

An extension lives one tab away from every workflow your users have. Getting it there means clearing the review, not just clearing the compiler.

Extensions live closer to the user than any other software

Web apps run inside their own tab. Mobile apps run inside their own icon. Extensions run inside every tab the user opens. That proximity is the whole point. It's also the reason browsers police them carefully, and why building one well means understanding the security model, the permission system, and the review process before you write the first line of code, not after.

The Chrome Web Store is one of the highest-distribution software channels there is. Reaching that installed base means clearing store policy from day one, not treating it as a formality after the code already works.

1.69B+
Chrome Web Store extension installs, all-time
chrome-stats.com, 2025
~180K
Extensions listed on the Chrome Web Store
chrome-stats.com, 2025
Jul 2025
Manifest V2 stopped running on stable Chrome (v138)
Chrome for Developers, MV2 timeline

RaftLabs has shipped production software since 2015 and holds a 4.9/5 rating on Clutch. We've also built and shipped our own browser extension: Draftly, an AI-assisted LinkedIn content tool with a native Chrome extension that worked inside the LinkedIn UI itself, no separate dashboard to context-switch to. RaftLabs sold Draftly in 2024 and no longer operates it, but the team that scopes your extension project is the same team that built and shipped that one.

Most teams that try to build an extension internally underestimate one of three things: how much of the work is store policy compliance rather than application logic, how much the Manifest V3 service worker model changes the assumptions you can make about background state, or how different the Safari distribution model is from Chrome. We scope every extension project around all three from day one, not as an afterthought once the code already works.

An extension pays off when it lives inside a workflow, and has to clear the store to get there.

Everything on the left should already be true for your build. Even one thing on the right, and a script or a bookmarklet is the smarter first step.

A fit
01

You need an extension that lives inside Chrome, Edge, Firefox, or Safari, built on Manifest V3 from day one.

02

The extension touches real workflows: an AI assistant, a CRM or sales prospecting tool, or an internal automation across tools your team already uses.

03

You want the Chrome Web Store submission and review handled end to end, with a fixed price before code is written.

Not a fit
  • You need a quick script or bookmarklet, not a store-published, maintained extension.
  • You want a Manifest V2 build; Chrome stopped accepting new MV2 submissions in 2024 and is phasing out the rest.
  • The idea depends on remotely hosted code executing inside the extension, which MV3 store policy prohibits.

What we build

What our browser extension development service covers

  • 01
    Chrome extension development
    Production Chrome extensions built on Manifest V3 with a clean service worker architecture, declarativeNetRequest for network behavior, and a popup UI in React or Svelte with TypeScript throughout. The permission model is designed for least privilege from day one, and Chrome Web Store submission is handled end to end, from listing copy and screenshots to privacy policy; if a submission is rejected, we revise and resubmit, typically within 48 hours.
  • 02
    Edge and Firefox extension development
    When a project needs Edge or Firefox alongside Chrome, we build from the same Manifest V3 codebase with the smallest possible per-browser delta. Edge accepts a Chrome build almost verbatim via the Microsoft Partner Center; Firefox resolves the browser.* namespace with webextension-polyfill so application code stays unified, and because Mozilla review is stricter on obfuscation we ship source maps and unminified source by default.
  • 03
    Safari Web Extensions for macOS and iOS
    When a project needs Safari, we wrap the same Manifest V3 codebase in a native Swift shell as a macOS and iOS app via Xcode. Because Safari distributes through the Mac App Store and iOS App Store, that means Xcode setup, code signing, notarization, and App Store Connect submission on top of the shared TypeScript codebase, so the extension logic stays the same across every browser even though the packaging doesn't.
  • 04
    AI assistant and productivity extensions
    Extensions that put an AI assistant inside the user's existing workflow: a sidebar beside any page, selection-based prompting from a keyboard shortcut, and output inserted back into editable surfaces like Gmail, Google Docs, Notion, and Salesforce. LLM API calls route through a backend service so keys never ship in the bundle and cost controls live server-side, while productivity extensions store data locally via chrome.storage rather than syncing to a server the user didn't ask for.
  • 05
    Sales and CRM browser extensions
    Extensions for sales prospecting and CRM workflows that live where the team already works: LinkedIn prospecting tools that push contacts into Salesforce or HubSpot with one click, and Gmail or Outlook sidebars that surface deal context next to every thread. For CRMs with public OAuth APIs we authenticate with OAuth 2.0 and PKCE; for platforms without them, a backend proxies requests, and bulk operations retry with backoff when the CRM throttles.
  • 06
    Extension store submission and approval
    End-to-end submission handling for the Chrome Web Store, Edge Add-ons, Firefox Add-ons, and the Mac and iOS App Stores, each with its own policy framework and review criteria. The Chrome package includes a privacy policy, a justification for every requested permission, listing copy, and screenshots, all of which we write; if a submission is rejected, we revise against the cited policy section and resubmit, usually within 48-72 hours.

Have an extension the store keeps rejecting?

Send us the rejection email and the manifest. We'll tell you why it failed and what it takes to pass the next review.

How it works

From scope to shipped

Every project follows the same four phases. Scope is locked and price is fixed before development starts.

  1. Week 1
    01

    Discovery and permission model

    We map the workflow the extension lives in, the browsers it needs to support, and the data it touches. You leave week 1 with a written scope document, a Manifest V3 permission model, and a fixed-price quote. No development starts without your sign-off.

  2. Weeks 2-3
    02

    Architecture and UI design

    Extension UI wireframes before production code. The permission scope, the service worker lifecycle, and the content script injection points are all locked here. Design decisions made in week 2 cost ten times less than the same decisions made in week 8.

  3. Weeks 4-12
    03

    Build, integrate, and QA

    Working extension installable from a staging build by end of sprint one. Bi-weekly demos. QA runs in parallel with every sprint, testing each browser target independently, not as a phase at the end.

  4. Weeks 12+
    04

    Store submission and post-launch support

    We handle the full store submission package and manage the review process. 8 weeks of post-launch support included in every project. If the store review triggers a rejection, we revise and resubmit within 48 hours.

What actually differs across the four browsers

One Manifest V3 codebase covers all four, but the store, the review, and the packaging are not the same everywhere. This is where an internal build usually loses a week it did not budget for.

Chrome and EdgeFirefoxSafari
ManifestManifest V3, shared codebaseManifest V3, browser.* namespaceManifest V3 wrapped in a native app
DistributionChrome Web Store and Microsoft Partner CenterFirefox Add-ons (AMO)Mac App Store and iOS App Store via Xcode
Review sticking pointPermission justification, single purposeSource review, no obfuscationApp Store review plus Apple Developer Program
Cost to addBaselineSmall API and manifest deltaXcode shell, code signing, notarization

Pitfalls we plan around before they cost you a release

Manifest V2 migration
No Manifest V2 extension has run on stable Chrome since Chrome 138 in July 2025, and the Chrome Web Store removes the last MV2 listings on 31 August 2026 (Chrome for Developers, MV2 deprecation timeline). An MV2 build is not a config tweak away from MV3. It is a rewrite of the background logic, the network interception layer, and often the storage model, so we scope it as its own project.
Store rejection
The common rejections are permission scope the described feature does not justify, a privacy policy that does not match real data use, single-purpose violations, and remotely hosted code, which MV3 prohibits. We write the listing, the privacy policy, and every permission justification to pass, and revise against the cited policy section within 48 hours if a review still fails.
Permission scares
An install prompt that asks for access to all sites costs you installs. We design for least privilege, request host access per-site or on demand through the activeTab pattern, and keep the prompt small enough that users say yes.
Auto-update breakage
Extensions update silently, so a bad release ships itself to every user at once. We stage rollouts, keep the service worker resilient to being stopped and restarted, and version any external API the extension depends on so a platform change does not brick it in the field.

What clients say

What our clients say

Three-year average engagement. Founders and operators describing the work in their own words. No marketing varnish.

Charles E.
Charles E.
USA flagUSA
Entrepreneur at Aggie Technologies

All of the sprints were completed on schedule and on budget. We highly recommend RaftLabs!

01 / 02

We give you a fixed cost before any code is written, not a time-and-materials estimate. Where you land in that range depends on scope, not negotiation:

Single-browser build, $15,000-$35,000
One core feature, a popup UI, content scripts, and Chrome Web Store submission handled end to end, in 4 to 6 weeks.
Cross-browser and backend, from there up
Chrome, Edge, and Firefox from one codebase adds roughly 15-25%. Safari Web Extensions add $8,000-$15,000. AI assistant, CRM, or data-layer backends are scoped in with the extension.

What it costs

Browser extension development, starting at $15,000.

A single-browser extension, cross-browser from one Manifest V3 codebase, or a full build with a backend and store submission handled end to end.

Starts at $15,000

Priced by project, not time-and-materials, quoted before any code is written. Most launch a validated v1 in 6-12 weeks. Many teams start with a single browser and add cross-browser or Safari support once they've validated demand.

Start with a single-browser extension, then expand to cross-browser or add Safari support once you've seen adoption. Store submission, and any rejection appeal, is handled either way.

No hourly billing

Once we scope the work, that price is locked in writing. No hourly billing, nothing absorbed quietly into the final invoice.

Store approval handled

We handle the full store submission package and manage the review. If it triggers a rejection, we revise against the cited policy section and resubmit within 48 hours, with 8 weeks of post-launch support included.

A browser extension rarely stands alone. AI assistant and CRM extensions usually need a backend: see API development for the integrations layer, or web application development if the extension is the entry point to a larger product. An extension is one piece of a broader build; for the rest of the system, see custom software development.

Stay on topic

More on web apps

Frequently asked questions

Manifest V3 is the current extension platform across Chrome, Edge, and Firefox. Manifest V2 is being retired, Chrome stopped accepting new MV2 submissions in 2024 and is phasing out existing MV2 extensions through 2025-2026. The difference is architectural, not cosmetic. MV2 used long-running background pages that stayed in memory the whole time the browser was running. MV3 replaces those with service workers that the browser starts and stops on demand, which means any state you used to hold in a background page now has to live in storage (chrome.storage.local or session). MV2 used blocking webRequest listeners that could rewrite or cancel network requests in real time. MV3 replaces that with declarativeNetRequest, a declarative rules engine where you register the rules ahead of time and the browser enforces them, which is faster and more private but stricter about what you can do. If your extension was built on MV2, the migration isn't a config change, it's a rewrite of the background logic, the network interception layer, and often the storage model. We build new extensions on MV3 from day one and migrate MV2 extensions to MV3 as a scoped project rather than a quick patch.

One codebase, multiple browsers, with the smallest possible per-browser delta. Chrome, Edge, and Firefox all consume Manifest V3 with the WebExtensions API, so the same content scripts, service worker, and popup UI run across the three with minor manifest differences. Edge accepts a Chrome build almost verbatim. Firefox needs a small number of API substitutions (browser.* vs chrome.* namespace, polyfilled via webextension-polyfill) and slightly different permission declarations. Safari is the outlier. Safari Web Extensions ship as macOS or iOS apps via Xcode, with the WebExtensions code wrapped in a native Swift shell, and they require an Apple Developer Program membership for distribution through the Mac App Store and iOS App Store. We build the core extension logic once in TypeScript, share content scripts and the popup UI across all four browsers, and maintain per-browser manifest files and the Safari Xcode wrapper as the only platform-specific pieces. That keeps maintenance cost down as the product evolves.

The review process has two stages. The automated scan checks for malware signatures, banned API usage, and obvious policy violations. The human review reads your store listing, tests the extension in a clean Chrome profile, and checks that the extension does what the listing says it does, with the permissions it requests, and no more. Reviews typically take 1-3 business days for established developer accounts and 1-3 weeks for new accounts on first submission. The most common rejection reasons we see and resolve are: requested permissions that aren't justified by the described functionality (asking for host_permissions on all_urls when the extension only needs to run on one site), a privacy policy that doesn't match what the extension actually does with user data, a single-purpose violation where the extension tries to bundle several unrelated features, remotely hosted code being executed (MV3 prohibits this, all code must ship in the package), and store listing screenshots or descriptions that overpromise what the extension does. When an extension is rejected, the rejection email cites the specific policy section. We know what each policy section means in practice, from shipping our own extension through review and staying current with store policy, and we revise the submission to pass on the next round, usually within 48 hours of the original rejection.

A focused single-browser extension, one core feature, popup UI, content scripts, and Chrome Web Store submission, typically runs $15,000-$35,000. Cross-browser builds (Chrome, Edge, Firefox from one codebase) add roughly 15-25%. Adding Safari Web Extensions (which requires the Xcode native shell and Apple Developer Program distribution) adds another $8,000-$15,000 on top. Extensions with backend services (AI assistants calling LLM APIs, CRM extensions syncing with Salesforce or HubSpot, sales tools with their own data layer) are scoped including the backend. We give you a fixed cost before any code is written, not a time-and-materials estimate.

Most extensions reach a store-ready v1 in 6-12 weeks from project start, then grow from there. A focused single-purpose extension on one browser can ship in 4-6 weeks. Cross-browser extensions with backend services typically run 10-14 weeks. The Chrome Web Store review adds 1-3 days for established developer accounts and 1-3 weeks for first-time submissions, which we factor into the launch date rather than treating it as an afterthought. We start with a 1-week discovery to confirm the permission model and the Manifest V3 architecture before writing application code, because a misjudged permission scope is the most common reason extensions get rejected or have to be rebuilt mid-project.

Yes. We sign NDAs before discovery calls for projects that involve proprietary workflows, internal tooling, or competitive product ideas. Full source code ownership transfers to you at project completion. We do not retain rights to use your extension or its underlying logic in other projects.

Work with us

Tell us what you need. We'll tell you what it would take.

We scope Browser Extension Development Company in 30 minutes. You walk away with a clear cost, timeline, and approach. No commitment required.

  • Scope and cost agreed before work starts. No surprises. No obligation.
  • Working prototype within 3 weeks of kickoff.
  • Pay by milestone. You see progress before each invoice.
  • 60-day post-launch warranty. Bug fixes, UI tweaks, and deployment support. No retainer.
  • All conversations are NDA-protected.