GITNUXSOFTWARE ADVICE
Education LearningTop 10 Best Proofread Software of 2026
Top 10 Proofread Software rankings compare tools like Grammarly, LanguageTool, and Scribens by accuracy, grammar fixes, and document support.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Grammarly
Granular writing suggestions with issue-level explanations and actionable replacements.
Built for fits when teams need enforced proofreading rules across common editors with controlled access..
LanguageTool
Editor pickAPI outputs match locations and suggestion metadata for programmatic document edits.
Built for fits when teams need proofreading integration and rule governance without custom NLP pipelines..
Scribens
Editor pickRules-based grammar, spelling, and style checks with structured issue categories.
Built for fits when teams need consistent proofreading rules without deep admin governance..
Related reading
Comparison Table
This comparison table maps proofreading and writing tools across integration depth, data model design, and automation plus API surface for grammar checks, style rules, and feedback rendering. It also compares admin and governance controls such as RBAC, provisioning workflows, and audit log coverage, which affect deployment at scale. Readers can use these dimensions to evaluate configuration, extensibility, and how each tool supports throughput for team and organization use cases.
Grammarly
generalist QAProvides AI-assisted grammar, spelling, and style checks with an editor integration, user settings, and organization management features for governance.
Granular writing suggestions with issue-level explanations and actionable replacements.
Grammarly runs proofreading where text is produced, not just after export, so teams can correct issues during drafting. Its integration depth covers browser editing, desktop apps, and other work tools, which reduces context switching. The data model is built around detected issues with selectable suggestions, which supports repeatable validation and review flows in connected systems. Admin controls support provisioning and policy configuration for organizations, including domain-level governance for managed users.
A key tradeoff is that deep automation depends on the specific integration surface rather than a single universal write-check endpoint for every environment. Grammarly fits best when teams need consistent proofreading rules across editors and want governance controls that reduce off-policy writing. A common usage situation is a marketing or customer-communications team standardizing tone and error handling while authors work in their existing editors.
- +Issue-based suggestions support consistent review and acceptance workflows
- +Browser, desktop, and editor integrations reduce drafting interruption
- +Team governance controls help enforce writing policies by domain
- +Extensibility via API and integrations supports embedding checks
- –Automation depth varies by integration surface and editor type
- –Policy configuration can require careful mapping to team standards
- –High-volume checks can add latency in complex editor sessions
Marketing operations teams
Standardize brand tone in shared drafts
Fewer revisions during approvals
Customer support teams
Proofread templates before publishing
More consistent customer replies
Show 2 more scenarios
Product writing teams
Maintain spec quality across authors
Cleaner releases and documentation
Applies shared proofreading checks to reduce inconsistencies in technical copy.
Software teams with tooling
Embed proofreading into internal editors
Automated lint-like writing checks
Uses API and integration surfaces to route text through a suggestion model.
Best for: Fits when teams need enforced proofreading rules across common editors with controlled access.
More related reading
LanguageTool
API-firstRuns open-source and hosted grammar, style, and rewriting checks with model configuration, rule-based behavior, and documented extension and API patterns.
API outputs match locations and suggestion metadata for programmatic document edits.
LanguageTool fits teams that need consistent proofreading in an editing UI or within an internal pipeline, because it offers both client-side integrations and an API for automated runs. The data model separates input text, language selection, and detected issues, which makes it practical to map suggestions back into documents or tickets. Extensibility comes from rule configuration and add-on mechanisms, which can be applied before or after issue detection to match team writing standards.
A tradeoff appears when workloads require high throughput, because large documents or many parallel API calls increase latency and require batching or queueing in the caller. LanguageTool works best when governance matters at the rule level, such as flagging specific error categories in customer-facing drafts and capturing consistent issue metadata for audit trails in downstream systems.
- +API returns structured issue spans for deterministic automation
- +Rule and language configuration supports consistent style enforcement
- +Editor and browser integrations reduce proofreading drift across tools
- +Extensibility via rules and add-ons helps match domain writing
- –High volume proofreading needs caller-side batching and rate control
- –Deep taxonomy tuning can be labor intensive for niche style guides
- –Complex documents may require careful language selection per section
Localization and content ops teams
Proofread multilingual drafts before release
Fewer release defects in published copy
Product teams with CI workflows
Block bad copy in pull requests
Consistent writing checks in reviews
Show 2 more scenarios
Customer support operations
Standardize macro and reply templates
Lower error rates in support replies
Configure style and grammar categories to keep canned responses consistent.
Regulated communications teams
Govern wording quality with audit logs
Traceable QA for released communications
Persist issue metadata from API runs to support traceable editorial governance.
Best for: Fits when teams need proofreading integration and rule governance without custom NLP pipelines.
Scribens
writing checksPerforms French and multilingual grammar and style checks with pattern rules and output highlighting suitable for embedding into education writing workflows.
Rules-based grammar, spelling, and style checks with structured issue categories.
Scribens fits teams that need repeatable proofreading across many writing surfaces like web forms, emails, and documents. The core value comes from a stable data model for detected issues, with check results grouped by type such as grammar, spelling, and style. Integration depth depends on where text is captured, since the product works best when content can be sent through its editor flow. Automation and extensibility are more practical for lightweight pipelines than for high-throughput batch processing.
A tradeoff appears for organizations needing centralized governance, because RBAC, audit log, and provisioning controls are not emphasized as part of the workflow. Scribens is a good fit when a small team wants consistent style guidance across daily writing and can tolerate limited admin control depth. It is less suitable when strict admin governance and API-first automation are required to meet compliance or integration throughput targets.
- +Language and rule configuration keeps proofreading output consistent
- +Editor flow supports quick proofreading inside common writing tasks
- +Issue grouping by grammar, spelling, and style simplifies review
- –API and automation surface is limited versus full integration suites
- –Admin governance features like RBAC and audit logs are not central
- –High-throughput batch processing is not the primary workflow
Marketing operations teams
Standardize campaign copy across multiple channels
Fewer copy edits post-approval
Customer support teams
Proofread responses for tone and correctness
More consistent support messaging
Show 2 more scenarios
Legal admin assistants
Review contracts for spelling and style
Cleaner drafts for attorneys
Scribens catches spelling and style deviations during document edits without a heavy workflow.
Product documentation editors
Maintain consistent writing across docs
Lower variance in documentation
Scribens enforces selected writing rules to keep documentation text uniform across updates.
Best for: Fits when teams need consistent proofreading rules without deep admin governance.
Ginger
writing checksOffers grammar and text correction with writing features that integrate into common editor experiences for classroom and student submissions.
Grammar and style correction engine that returns structured edits for proofreading.
In proofread software for writing teams, Ginger focuses on language processing, style checks, and structured corrections inside document workflows. Its value comes from correction suggestions tied to language rules, not just generic rewrites.
Admin review can be combined with team rollout by configuring usage settings across users and managed instances. Integration and automation depend on Ginger’s available API and export points, which determine how edits enter existing authoring, review, and governance pipelines.
- +Language-aware corrections with reusable style and grammar rules
- +Document-oriented workflow fits publishing and review cycles
- +Admin configuration supports controlled rollout to user groups
- –Automation depth depends on the availability of API and webhooks
- –Governance controls like RBAC and audit logs may be limited
- –Data model for review history can be harder to integrate deeply
Best for: Fits when teams need consistent grammar and style correction inside document review workflows.
WhiteSmoke
writing checksProvides grammar and style proofreading through browser and editor-oriented workflows with correction suggestions for student writing review.
Inline proofreading in the writing editor with rule-based grammar and style corrections.
WhiteSmoke provides proofreading and writing assistance through an integrated editor workflow. It focuses on English grammar, spelling, and style checks with configurable writing feedback.
Integration depth is mostly limited to editor-based usage rather than broad system provisioning. Automation and API surface are not clearly positioned as a first-class automation interface, which affects governance and data model control.
- +Editor workflow supports inline grammar, spelling, and style suggestions
- +Configurable writing rules help standardize outputs across documents
- +Feedback is presented in a way suited for human review cycles
- +Extensible guidance reduces repeated rework for common writing issues
- –API and automation surface is not positioned for programmatic governance
- –Provisioning and RBAC controls are not documented around external integrations
- –Data model and schema controls are limited to document-level feedback
- –Audit log details for enterprise review and traceability are not emphasized
Best for: Fits when teams want editor-based writing checks without building API-driven automation pipelines.
Reverso
writing checksDelivers grammar and text correction assistance with web and writing support features used for quick student proofreading review.
Glossary-driven term enforcement for context-aware rewrites during proofreading workflows.
Reverso targets proofing and language refinement tasks with translation memory, term handling, and document-level workflow. It is distinct for using context-aware suggestions that can align phrasing across sentences and segments.
Reverso supports team usage patterns through configurable projects and reusable glossaries that reduce repeated wording drift. The practical value comes from integration depth into review workflows rather than from a single editing widget.
- +Glossary controls term consistency across repeated documents
- +Context-aware suggestions reduce rework when editing long text
- +Document-level workflow supports bulk proofreading sessions
- +Configurable projects enable consistent reviewer instructions
- +Translation-memory style reuse supports phrasing continuity
- –Deep customization depends on integration and configuration details
- –Automation and API surface depth is harder to validate from UI alone
- –Governance features like fine-grained RBAC and audit logs are not explicit
- –Terminology management can require ongoing glossary maintenance
- –Turnaround control needs careful workflow design for high throughput
Best for: Fits when teams need consistent wording across documents with controlled glossary usage.
ProWritingAid
reporting QAPerforms grammar and style analysis with report outputs that support consistent feedback across student drafts.
Report mode groups findings by category and severity with traceable suggestions across a document.
ProWritingAid combines grammar, style, and report-driven writing feedback in one editor workflow. It supports deep rule categories like style consistency and overused words, with targeted fixes generated from its analysis engine.
The system’s value comes from repeated, configurable checks and exportable reports that fit document review cycles. Integration depth is mostly editor-centric, with limited emphasis on a public API surface and admin-grade governance features.
- +Configurable writing reports with repeatable rule sets
- +Detailed style and consistency diagnostics with actionable suggestions
- +Works inside common writing flows with exportable review outputs
- +Rule coverage includes overused words and sentence-level issues
- –Limited documented API surface for automation and external systems
- –Admin and RBAC controls for governance are not a primary focus
- –Extensibility is constrained versus tools with plugin schemas
- –Automation throughput depends on interactive editor usage
Best for: Fits when individual authors or small teams need repeatable writing checks with minimal automation governance.
PaperRater
education feedbackGenerates writing feedback that includes grammar and proofreading assistance for educational submissions in an automated workflow.
Segment-level annotations that associate grammar and style findings to the exact source spans.
PaperRater is a proofreading and writing feedback tool that processes text for grammar, spelling, and style issues. Feedback is delivered as annotated results tied to the original writing, which supports repeatable review workflows.
For organizations evaluating proofread software, PaperRater’s key differentiator is how consistently it maps issues back to source text. Integration depth and automation depend on the available API and data schema options for extracting results and driving downstream governance workflows.
- +Annotated feedback ties findings to specific text segments for review workflows
- +Consistent grammar and style checks reduce manual re-reading effort
- +Works well for batch submissions when throughput is needed
- +Exports and report views support review and documentation handoff
- –API and automation surface is limited for deep workflow integration
- –Data model details for integrations are harder to map into strict schemas
- –Admin and governance controls for RBAC and audit logs are not explicit
- –Extensibility hooks for custom rule sets are not clearly documented
Best for: Fits when teams need text-anchored proofreading output with minimal workflow engineering.
Hemingway Editor
readability QAFlags readability issues and sentence complexity so reviewers can simplify drafts during proofreading passes.
Live readability scoring with color-coded highlights for complex and passive constructions.
Hemingway Editor performs readability-focused proofreading by flagging complex sentences, passive voice, and hard-to-read phrasing in a live editor. It applies a consistent grading view based on sentence structure cues and provides color-coded suggestions tied to those diagnostics.
Its workflow is centered on document text cleanup rather than content governance or team workflows. Integration depth is limited because Hemingway Editor does not expose a documented automation API or provisioning model for external systems.
- +Color-coded diagnostics for readability issues like passive voice and complex sentences
- +Compact editing workflow for rapid iterative revision of plain text
- +Actionable suggestions are tied directly to flagged sentence structures
- +Cross-platform editor experience supports consistent proofreading sessions
- –No documented API or automation hooks for external proofreading pipelines
- –No RBAC, audit log, or governance controls for multi-user environments
- –No data model or schema for integrating findings into other systems
- –Limited configuration surface for aligning rules to custom style guides
Best for: Fits when individual writers need fast, repeatable readability checks without team governance requirements.
QuillBot
rewriting assistantProvides rewriting and text transformation with quality checks that can be used to correct grammar and improve wording before submission.
Sentence rewriting with selectable style controls for producing alternative phrasings from drafts
QuillBot fits teams that need revision and proofreading support inside everyday writing workflows. It rewrites sentences with configurable style controls and can run as a browser-side tool for direct text editing.
Core capabilities include grammar checks, rewriting, summarization, and paraphrasing aimed at producing alternative phrasing from an existing text draft. QuillBot’s value is mainly governed by its text transformation workflows rather than deep enterprise integration.
- +Configurable rewriting modes with direct sentence-level editing
- +Browser-based workflow supports quick proofreading without document handoffs
- +Built-in grammar and rewriting tools cover common drafting iterations
- +Summarization and paraphrasing enable faster content variants
- –Limited evidence of an enterprise RBAC and provisioning model
- –Automation and API surface are not clearly positioned for workflow orchestration
- –Audit log and governance controls are not documented for admin review
- –Data model details for integrations and extensibility are unclear
Best for: Fits when individuals or small teams need rewrite-and-proof cycles inside the same writing session.
How to Choose the Right Proofread Software
This buyer’s guide covers Grammarly, LanguageTool, Scribens, Ginger, WhiteSmoke, Reverso, ProWritingAid, PaperRater, Hemingway Editor, and QuillBot for proofreading and language quality workflows.
It focuses on integration depth, the underlying data model for issues and edits, automation and API surface, and admin and governance controls so tool behavior stays consistent across teams and document pipelines.
Proofread software that produces actionable edits and traceable findings inside writing workflows
Proofread software analyzes text for grammar, spelling, style, and readability signals, then returns issue spans and suggested replacements that match the original source positions. Tools like LanguageTool output structured issue spans and suggestion metadata for programmatic edits, while Grammarly returns issue-level explanations with actionable replacements inside editor integrations.
These tools reduce manual re-reading by anchoring feedback to the exact text segments and by applying configurable rules or glossaries that keep writing conventions consistent across repeated drafts. Typical users include education teams submitting student writing for batch feedback, and writing teams that need enforced proofreading rules inside common authoring environments like browser editors and desktop apps.
Evaluation criteria tied to integration, issue schema, automation, and governance
Proofreading quality depends on how findings map back to source text, not just how many errors are detected. LanguageTool and PaperRater both emphasize span-level mapping, which supports automation and review traceability.
Integration depth and governance controls determine whether proofreading can run as part of a controlled workflow with RBAC and audit visibility. Grammarly and Ginger emphasize admin configuration and controlled rollout, while WhiteSmoke and Hemingway Editor concentrate on editor usage with limited automation and governance exposure.
Issue-to-source anchoring using spans for edits and annotations
LanguageTool returns issue spans plus suggestion metadata, which supports deterministic automation that edits specific locations in a document. PaperRater ties grammar and style findings to exact source spans as annotated results, which supports review handoff without losing context.
Deterministic structured outputs for programmatic rewriting
LanguageTool’s API outputs match locations and include suggestion metadata, which enables apps to apply edits without screen scraping. Ginger and Grammarly also return structured corrections inside writing workflows, but automation depth varies by editor integration surface.
Integration depth across browser editors and desktop writing workflows
Grammarly covers browser, desktop, and editor integrations, which reduces drafting interruption by running proofreading in the authoring moment. WhiteSmoke and Hemingway Editor focus on an editor-oriented workflow, which can limit integration breadth into external systems when automation is required.
Automation and API surface for embedding proofreading in custom pipelines
LanguageTool is built for API-based proofreading for apps that need automated quality checks. Grammarly supports an API-oriented extensibility path for embedding checks into custom tools, while ProWritingAid and QuillBot focus more on interactive editing and report or rewrite modes than on a clearly positioned automation interface.
Governance controls such as admin configuration, team controls, and audit traceability
Grammarly includes organization management features and team governance controls aligned to domain writing standards, which supports enforced proofreading rules across users. Ginger supports admin review combined with managed rollout via usage settings, while WhiteSmoke, Hemingway Editor, and QuillBot do not emphasize RBAC and audit log controls for multi-user governance.
Rule and knowledge model configuration for consistent conventions
Scribens uses a rules engine with language selection and structured issue categories to keep output consistent across proofreading passes. Reverso adds glossary controls for term consistency across documents, while ProWritingAid provides repeatable rule categories with report mode diagnostics for style consistency.
Pick a proofreading tool by mapping edits, automation hooks, and governance needs to the issue model
Start by deciding whether proofreading must return machine-actionable results that can be applied without human review. LanguageTool’s API outputs issue spans and suggestion metadata, and PaperRater emits segment-level annotations that support traceable review workflows.
Then confirm whether the tool supports the operational model needed for teams. Grammarly and Ginger provide admin configuration for controlled rollout, while Hemingway Editor and WhiteSmoke concentrate on single-user editor workflows with limited automation and governance exposure.
Define the output contract needed for edits or annotations
If downstream automation must apply changes to specific text locations, choose LanguageTool because its API outputs match locations and include suggestion metadata. If the workflow requires review artifacts tied to exact source spans, choose PaperRater because it generates annotated results that associate issues to precise segments.
Match integration depth to where writing actually happens
For teams that need proofreading inside browser and desktop editors, choose Grammarly because it integrates with web editors and desktop apps. If proofreading is mainly an editor pass with readable highlights, choose Hemingway Editor for color-coded readability diagnostics, but expect limited automation hooks.
Validate automation and API surface against the required throughput model
For apps that need API-driven proofreading, choose LanguageTool because it supports API-based proofreading and structured issue spans for programmatic edits. If the workflow depends on interactive usage, choose ProWritingAid for report-driven category severity feedback, but plan for automation throughput to depend on editor or report generation rather than a deep API-first interface.
Confirm governance and administration controls for multi-user environments
For enforced writing standards across many users and domains, choose Grammarly because it includes organization management and team governance controls. For controlled rollout using usage settings across user groups, choose Ginger, while tools like Hemingway Editor and QuillBot do not emphasize RBAC and audit log governance controls.
Choose a configuration model that matches style enforcement strategy
If consistent rule-based proofreading across categories is the priority, choose Scribens because configuration centers on language selection and writing rules that shape structured issue categories. If term consistency across repeated documents is the priority, choose Reverso because glossary controls enforce consistent wording during context-aware rewrites.
Teams and individuals who get the most value from specific proofreading models
Proofread software fits different operational models depending on how findings must be enforced and how results must be consumed. Some teams need governed standards across shared editors, while others need segment-anchored outputs or glossary-driven consistency for repeated documents.
The best fit also depends on whether the primary job is editor-integrated corrections, API-driven automation, or readability diagnostics.
Teams enforcing proofreading rules across common editors with controlled access
Grammarly fits this model because it integrates across browser, desktop, and editor workflows and includes organization management plus team governance controls for domain writing standards.
Organizations integrating proofreading into apps using a structured issue schema
LanguageTool fits this model because its API outputs return issue spans and suggestion metadata that map directly to programmatic document edits.
Educators and workflow owners needing segment-level annotated feedback for batch review
PaperRater fits this model because annotated results tie grammar and style findings to exact source spans, which supports repeatable review and documentation handoff.
Writers who want fast readability cleanup without multi-user governance requirements
Hemingway Editor fits this model because it provides live readability scoring with color-coded highlights for complex sentences and passive voice, and it does not emphasize RBAC or an automation API.
Teams that need term consistency across document sets using glossary enforcement
Reverso fits this model because glossary controls support controlled term usage and context-aware suggestions that reduce phrasing drift across sentences.
Pitfalls that break proofreading workflows when integration and governance are overlooked
Several common failures come from mismatches between how findings are produced and how the workflow expects to consume them. When automation must edit specific spans, tools without a clearly positioned structured output interface create integration friction.
Governance gaps also cause failures in team rollouts when RBAC and audit visibility are not documented or not central.
Choosing an editor-only tool for an automation-first pipeline
Avoid Hemingway Editor and WhiteSmoke for API-driven governance workflows because both focus on editor-facing diagnostics and do not emphasize a documented automation API or provisioning model. Choose LanguageTool if programmatic document edits require structured issue spans and metadata.
Assuming all tools provide span-level mappings back to the original text
Do not assume segment anchoring is available when integrating into strict review schemas because Scribens and ProWritingAid can emphasize structured issue categories and reports rather than an API-first span contract. Choose PaperRater for segment-level annotations tied to exact source spans.
Underestimating governance and rollout complexity in multi-user environments
Avoid tools that do not center RBAC and audit log controls such as Hemingway Editor, WhiteSmoke, QuillBot, and ProWritingAid when enterprise governance is required. Choose Grammarly for organization management and team governance controls or Ginger for controlled rollout via usage settings.
Confusing rule tuning work with plug-and-play configuration
Do not expect deep taxonomy tuning to be free when enforcing niche style guides because LanguageTool’s rule and language configuration can require careful mapping. Choose Scribens if consistency comes primarily from its rules engine and structured issue categories without needing extensive language and rule taxonomy engineering.
Picking rewrite-centric tools without a clear enforcement model for terms
Avoid QuillBot for term enforcement and glossary-driven consistency because its value centers on rewrite and transformation workflows rather than glossary controls. Choose Reverso when glossary-driven term consistency is a core requirement during proofreading.
How We Selected and Ranked These Tools
We evaluated Grammarly, LanguageTool, Scribens, Ginger, WhiteSmoke, Reverso, ProWritingAid, PaperRater, Hemingway Editor, and QuillBot using criteria tied to feature set, ease of use, and value. Features carried the most weight in the overall score, while ease of use and value each mattered strongly, producing a weighted average where feature coverage drove the ranking order most consistently.
Grammarly separated from lower-ranked options because it pairs issue-level explanations and actionable replacements with integration across browser, desktop, and editor workflows, plus organization management and team governance controls. That combination increased both the feature coverage and the practical fit for controlled multi-user proofreading inside common authoring environments.
Frequently Asked Questions About Proofread Software
Which proofreading tools offer API-based automation rather than editor-only checks?
How do Grammarly and LanguageTool differ in how teams govern what gets flagged?
Which tools produce structured issue data mapped back to the original text spans?
What are the main workflow tradeoffs between browser-first tools and editor-workflow tools?
Which tool is best suited for enforcing consistent terminology across documents?
Which tools provide admin-grade controls and auditability features for teams?
How should teams handle data migration when moving proofreading outputs into an existing review system?
Which tools are better for readability scoring versus writing standards enforcement?
When extensibility needs include custom checks embedded into other applications, which tools fit best?
Conclusion
After evaluating 10 education learning, Grammarly stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
Education Learning alternatives
See side-by-side comparisons of education learning tools and pick the right one for your stack.
Compare education learning tools→FOR SOFTWARE VENDORS
Not on this list? Let’s fix that.
Our best-of pages are how many teams discover and compare tools in this space. If you think your product belongs in this lineup, we’d like to hear from you—we’ll walk you through fit and what an editorial entry looks like.
Apply for a ListingWHAT THIS INCLUDES
Where buyers compare
Readers come to these pages to shortlist software—your product shows up in that moment, not in a random sidebar.
Editorial write-up
We describe your product in our own words and check the facts before anything goes live.
On-page brand presence
You appear in the roundup the same way as other tools we cover: name, positioning, and a clear next step for readers who want to learn more.
Kept up to date
We refresh lists on a regular rhythm so the category page stays useful as products and pricing change.