textrazor.com

TextRazor is a natural language processing API that extracts meaning from text, and its core capabilities are entity extraction, disambiguation and linking; keyphrase extraction; automatic topic tagging and classification; and deeper semantic analysis covering relations, typed dependencies and synonyms. It works across 19 languages and can classify content against the full IAB Content and IPTC Media Topic taxonomies. It is available as a cloud service or as self-hosted infrastructure, and you can evaluate it with a free API key and the online demo before committing to integration.

Core extraction features

Entity extraction, disambiguation and linking

TextRazor identifies the entities mentioned in your content and resolves which real-world thing each mention refers to, then links it to a knowledgebase entry. This matters when the same name could mean several things — a company, a person, a place — and you need the right one for downstream search, tagging or analytics.

Keyphrase extraction

The API pulls out the significant phrases in a document rather than just single words, giving you a compact summary of what the text is about. This is useful for indexing, summarization and content recommendation.

Automatic topic tagging and classification

TextRazor tags and classifies content automatically, and it supports the full IAB Content and IPTC Media Topic taxonomies. If your organization already uses those standard taxonomies for ad targeting, content management or media metadata, you can map results directly instead of building a custom category scheme.

Deeper semantic analysis

Beyond surface extraction, TextRazor performs deep analysis to surface:

• Relations — connections between entities and concepts in the text
• Typed dependencies — grammatical relationships between words that reveal sentence structure
• Synonyms — alternative wordings that help with context-aware matching

These outputs support applications that need to understand context rather than just count keywords, such as semantic search, question answering and content enrichment.

What the demo shows

The site's demo uses a news passage about Barclays, Sheikh Mansour and Abu Dhabi investment to illustrate extraction. Running text like this through the API is a practical way to see how entities, keyphrases and topics come back before you write any code. The site also provides getting-started material, tutorials, and reference documentation for Python, PHP, Java and the REST API, plus a Custom Logic Engine for tailoring analysis.

Choosing between cloud and self-hosted

If your content cannot leave your infrastructure, the self-hosted option is the relevant one; otherwise the cloud API is the faster path. Check the pricing page for plan details and any limits before you decide, since the site lists pricing and login/sign-up as separate steps.

Practical next steps

1. Sign up for a free API key and run a sample of your own text through the demo to confirm the output matches your needs.
2. Pick the client reference for your stack (Python, PHP, Java or REST) and follow the getting-started tutorial.
3. Test on a representative batch of your documents — especially ambiguous names and multi-language content — to see how disambiguation and the 19-language support perform.
4. If you need custom rules, evaluate the Custom Logic Engine; if data residency is a constraint, confirm self-hosted deployment requirements.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

To start with TextRazor, sign up on textrazor.com to obtain a free API key, then use the demo to see the output before writing any code. From there, work through the Getting Started tutorial and pick the reference for your language (Python, PHP, Java, or REST). TextRazor is a natural language processing API that extracts entities, keyphrases, topics, relations, and typed dependencies from text in 19 languages, and it runs either in the cloud or self-hosted.

Step 1: Create an account and get an API key

The site's navigation includes Sign up and Login links alongside Pricing. The page states that a free API key is available, so the practical first step is to register and retrieve your key from the account area. Every API call you make will be authenticated with that key, so keep it out of public repositories.

Step 2: Try the demo before you build

The homepage offers a Try The Demo option and shows a sample news article about Barclays as example input. Running your own text through the demo is the fastest way to see what the API returns — which entities it links, which keyphrases it ranks, and how it tags topics — before you commit to an integration. Use a short paragraph of your own content rather than the sample, so the output reflects your actual use case.

Step 3: Choose your integration path

TextRazor documents several ways to call the API. Pick based on your stack:

The general flow is the same in each case: send text plus your API key to the service, and receive structured analysis back. Start with the Getting Started tutorial to confirm your key works, then move to your language reference for the details of request parameters and response fields.

Step 4: Decide which analyses you need

The API covers several distinct capabilities, and you don't have to use all of them:

• Entity extraction, disambiguation, and linking — identifies people, organizations, and places in the text and links them to knowledgebase entries. In the sample article, this is what would resolve "Barclays," "Sheikh Mansour," and "Abu Dhabi" as distinct, linked entities.
• Keyphrase extraction — surfaces the main phrases in a document.
• Topic tagging and classification — assigns topics using the full IAB Content and IPTC Media Topic taxonomies.
• Deeper analysis — relations, typed dependencies between words, and synonyms, for context-aware semantic applications.

If you only need to tag a stream of articles by subject, topic classification plus keyphrases may be enough. If you're building search or knowledge-graph features, entity linking and relations matter more.

Step 5: Plan for deployment and volume

TextRazor offers both a complete cloud service and self-hosted infrastructure. The cloud option is the default starting point; self-hosting becomes relevant if you have data-residency or throughput requirements that a hosted API can't meet. Pricing details are on the separate Pricing page — check it before you scale past experimentation, since the free key is intended for trying the API, and production volume terms are set out there.

Common sticking points

• Skipping the demo. Teams often go straight to code and then struggle to interpret response fields. Ten minutes with the demo on your own text prevents that.
• Assuming one language. The API supports 19 languages, but confirm yours is among them before designing around it.
• Ignoring taxonomy fit. Classification maps to IAB and IPTC taxonomies; if your content doesn't fit those categories, plan to map the returned topics onto your own scheme.
• Key handling. The key is tied to your account, so treat it as a secret from the first commit.

TextRazor offers two deployment paths — a cloud API and self-hosted infrastructure — and separates access into a free API key and paid plans listed on its pricing page. The right choice depends on three things you can check before committing: whether your content can leave your environment (self-hosted vs. cloud), how much text you'll process (free key vs. paid plan), and which analysis features you actually need (entity/keyphrase/topic extraction vs. deeper relations and dependencies). The site does not publish specific prices or quotas in the material available here, so confirm current limits and costs on the pricing page before deciding.

What TextRazor provides

The API extracts meaning from text across 19 languages, with these documented capabilities:

• Entity extraction, disambiguation, and linking — identifies people, organizations, places, and links them to a knowledgebase of real-world facts.
• Keyphrase extraction — pulls out the significant phrases in a document.
• Automatic topic tagging and classification — maps content to the full IAB Content and IPTC Media Topic taxonomies.
• Deeper semantic analysis — relations, typed dependencies between words, and synonyms, for context-aware applications.

The site positions this as combining state-of-the-art NLP techniques with a comprehensive knowledgebase, and claims high accuracy and speed. It also offers a demo and reference material for Python, PHP, Java, and REST.

Cloud vs. self-hosted: the first decision

The site states it offers "a complete cloud or self-hosted text analysis infrastructure" but does not publish self-hosted licensing terms or requirements here. If data cannot leave your network, treat self-hosting as the candidate option and confirm terms directly.

Free API key vs. paid plan

The homepage offers a free API key and a demo, with paid plans on a separate pricing page. The free key is the natural way to evaluate accuracy on your own content before buying. Because the available material does not state free-tier quotas, rate limits, or prices, use the free key to test, then check the pricing page for the limits that matter to you: request volume, document size, and which features are included at each tier.

Matching a plan to your analysis needs

Use this sequence to narrow the choice:

1. List the features you need. If entity extraction, keyphrases, and topic tagging cover your use case, you have the widest plan range. If you need relations, typed dependencies, or synonyms, confirm those are included in the tier you pick.
2. Check language coverage. All 19 languages are advertised as part of the API; verify your specific languages against the documentation.
3. Estimate volume. Run a representative sample through the free key, measure throughput and output quality, then size the plan.
4. Decide on deployment. If legal or security review rules out sending text to a third party, move to the self-hosted conversation early.

Getting started and verifying fit

The site links a Getting Started guide, tutorials, and language-specific references (Python, PHP, Java, REST). A practical evaluation path:

• Sign up for the free API key.
• Run the demo text — the site's sample news article about Barclays is a good benchmark — and inspect the entities, keyphrases, and topics returned.
• Run a sample of your own content in your target languages.
• Compare output against your requirements, then check the pricing page for the tier that fits.

Common sticking points: assuming the free key has no limits (check the pricing page), assuming self-hosted is included in a standard plan (confirm separately), and evaluating only on English if your production content is multilingual.

TextRazor supports 19 languages and is built to analyze text from documents, tweets, and web pages. The same API that extracts entities, keyphrases, topics, and relations in one language can be pointed at content in any of the supported languages, and the service is offered as either a cloud API or self-hosted infrastructure. The practical limits are less about content type and more about how cleanly the text can be passed to the API and how well the knowledgebase covers the entities you care about.

Languages: 19, with language-specific reference material

TextRazor states that its entity extraction, disambiguation and linking, keyphrase extraction, and automatic topic tagging and classification all work across 19 languages. The site does not publish the full list on the page reviewed here, so if your project depends on a specific language, confirm it against the documentation before committing.

What the site does make clear is that client support is language-specific in a different sense: there are separate reference guides for Python, PHP, Java, and the REST API. That means you can call the service from most stacks, but the examples and method names you follow will differ depending on which reference you use. Pick the reference that matches your stack first, then check that your content language is among the 19.

Content types: documents, tweets, and web pages

The site names three content types explicitly:

• Documents — long-form text such as reports, articles, or internal files.
• Tweets — short, informal social posts.
• Web pages — content pulled from the web.

The demo text on the site is a news-style passage about Barclays, Sheikh Mansour, and Abu Dhabi investment, which shows the kind of prose the entity and relation extraction is designed around. Short tweets and web pages are supported, but they behave differently: a tweet gives the model very little context, and a web page may include navigation, ads, or boilerplate that you should strip before sending text for analysis.

What the analysis actually returns

Across those languages and content types, TextRazor extracts:

The knowledgebase is described as a comprehensive set of real-life facts, which is what allows disambiguation — deciding, for example, which "Barclays" or which "Abu Dhabi" entity a mention refers to. That knowledgebase is the main reason results vary by content: well-known entities resolve cleanly, while obscure or very new names may not.

Choosing based on your content

• If your text is long-form English or another major language, the standard extraction pipeline is the natural fit; the demo passage is representative of what it handles well.
• If you are processing social posts, expect to send shorter text and treat entity linking as less reliable, since there is less surrounding context to disambiguate with.
• If you are scraping web pages, clean the text first so navigation and boilerplate do not pollute keyphrases and topics.
• If you need a specific language outside the common ones, verify it against the documentation before building around it, because the site confirms the count of 19 but not the list.
• If data residency matters, the self-hosted option is the relevant choice; the cloud API is the default path.

To try it against your own content, the site offers a demo and a free API key, and the getting-started tutorials plus the Python, PHP, Java, and REST references cover the integration step.