# J-PlatPat Japan Patent & Trademark Crawler (`jungle_synthesizer/j-platpat-patent-crawler`) Actor Search Japanese patents, utility models, trademarks and designs from J-PlatPat, the Japan Patent Office database. Returns titles, applicants, inventors, FI/IPC codes, claims, abstracts, filing dates and grant status. - **URL**: https://apify.com/jungle_synthesizer/j-platpat-patent-crawler.md - **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community) - **Categories:** Business, Developer tools, Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.80 / 1,000 record scrapeds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## J-PlatPat Japan Patent, Trademark & Design Crawler Searches J-PlatPat, the Japan Patent Office's official database, and returns patents, utility models, trademarks and designs as clean JSON. Japan files roughly 300,000 patent applications a year, and until now none of it was one input form away. *** ### J-PlatPat Crawler Features - Searches patents and utility models by keyword, applicant, inventor, FI/IPC classification code or filing-date window. - Looks up a single patent application by number. - Returns patent inventors, IPC codes, claims count, abstract, registration date and priority claim alongside the search hit. - Searches trademarks by mark or owner, with a Nice class filter. - Searches designs by article or owner. - Links every patent back to its J-PlatPat document page. - Reaches past the 3,000-row display ceiling on patent searches by splitting the query across filing dates, so a broad query still returns everything it matches. *** ### Who needs Japanese patent data? - **IP counsel and patent agents** — Prior-art and freedom-to-operate checks against Japanese filings, exported rather than copied from a results screen. - **R\&D and competitive intelligence teams** — Track what a competitor files in a classification code, quarter by quarter. - **Trademark and brand teams** — Check a mark and its Nice class against the Japanese register before launch. - **Analysts and researchers** — Build filing-trend datasets by applicant, technology class or year. - **Licensing and M\&A teams** — List a target's patent portfolio with inventors and classification codes. *** ### How J-PlatPat Crawler Works 1. Pick a search type: patent (patents and utility models), trademark or design. 2. Set the filters that apply. Keywords are separated by spaces and must all match, up to four. 3. Run it. Patent hits come back newest filing first, enriched with inventors, IPC codes, claims count and abstract unless you turn details off. 4. Download the dataset as JSON, CSV or Excel. *** ### Input ```json { "searchType": "patent", "searchQuery": "量子", "searchField": "title", "applicant": "", "ipcCode": "G06N", "dateFrom": "2025-01-01", "dateTo": "2025-12-31", "fetchDetails": true, "maxItems": 50 } ``` | Field | Type | Default | Description | |---------------------|---------|-----------|--------------------------------------------------------------------------------------------------------------| | `searchType` | string | patent | `patent` (patents and utility models), `trademark` or `design`. | | `searchQuery` | string | | Keywords separated by spaces, all must match, up to four. Japanese text works best. | | `searchField` | string | full_text | Patents only. Where the keywords must appear: `full_text`, `title`, `abstract` or `claims`. | | `applicant` | string | | Applicant or owner name in Japanese, partial names match. Trademarks and designs use it as the search when no query is set. | | `inventor` | string | | Patents only. Inventor name in Japanese, partial names match. | | `ipcCode` | string | | Patents only. Classification code or prefix, for example `H04L` or `G06N10/40`. | | `applicationNumber` | string | | Patents only. One application, for example `2024-123456` or `JP2024-123456`. Overrides the other patent filters. | | `niceClass` | string | | Trademarks only. Keep only marks in this Nice class (1 to 45). | | `dateFrom` | string | | Earliest filing date, `YYYY-MM-DD`. | | `dateTo` | string | | Latest filing date, `YYYY-MM-DD`. | | `fetchDetails` | boolean | true | Patents only. Adds inventors, IPC codes, claims count, abstract, registration and priority data. Slower. | | `maxItems` | integer | 50 | Maximum records to return. | A patent search needs at least one of query, applicant, inventor, classification code, application number or a date window. Trademark and design searches need a query or an applicant. More examples: ```json { "searchType": "patent", "applicant": "トヨタ自動車", "dateFrom": "2024-06-01", "dateTo": "2024-06-30", "maxItems": 200 } ``` ```json { "searchType": "trademark", "searchQuery": "ロボット", "niceClass": "9", "maxItems": 100 } ``` *** ### J-PlatPat Crawler Output Fields Patent record: ```json { "document_type": "Patent", "application_number": "2025-075820", "publication_number": "特開2026-171612", "registration_number": null, "title_jp": "構造パラメータに基づく量子情報処理装置", "applicant_jp": ["エコツーラボ合同会社"], "inventors": ["猪澤 也寸志"], "filing_date": "2025-04-12", "first_published_date": "2026-10-23", "status": "Published application", "fi_codes": ["G06N10/40"], "ipc_codes": ["G06N10/40"], "claims_count": 19, "source_url": "https://www.j-platpat.inpit.go.jp/c1801/PU/JP-2026-171612/11/ja" } ``` | Field | Type | Description | |-------------------------|--------|-----------------------------------------------------------------------------| | `document_type` | string | Patent, Utility Model, Trademark or Design. | | `application_number` | string | Application number as `YYYY-NNNNNN`. | | `publication_number` | string | Publication number of the unexamined application (patents). | | `registration_number` | string | Registration or grant number in J-PlatPat's own notation. | | `title_jp` | string | Title of the invention in Japanese (patents). | | `abstract_jp` | string | Abstract in Japanese (patents, with details). | | `applicant_jp` | array | Applicants or owners in Japanese. | | `inventors` | array | Inventor names in Japanese (patents, with details). | | `filing_date` | string | Filing date, `YYYY-MM-DD`. | | `first_published_date` | string | Date of the earliest publication or gazette issue. | | `registration_date` | string | Registration date (granted patents, with details; registered trademarks). | | `priority_date` | string | Earliest claimed priority date (patents that claim priority, with details). | | `priority_country` | string | Country code of the earliest priority claim. | | `status` | string | Granted, Published application, Registered or Not registered. | | `fi_codes` | array | FI classification codes (patents). | | `ipc_codes` | array | IPC classification codes (patents, with details). | | `claims_count` | number | Number of claims (patents, with details). | | `mark_text` | string | Trademark text (trademarks). | | `mark_reading` | string | Katakana reading of the trademark (trademarks). | | `classes` | array | Nice classes as numbers (trademarks). | | `article_name` | string | Article the design applies to (designs). | | `design_classification` | string | Japanese design classification (designs). | | `source_url` | string | Link to the document on J-PlatPat (patents). | Trademark and design records carry only the fields that apply to them. *** ### FAQ #### Does J-PlatPat Crawler return English titles and abstracts? J-PlatPat Crawler returns what the Japan Patent Office publishes, which is Japanese. Titles, abstracts, applicant and inventor names are in Japanese, and classification codes are language-neutral. English fields would be machine translation, so none are added. #### How many records can one search return? J-PlatPat Crawler has no row limit on patent searches: a query that matches more than 3,000 patents is split across filing dates until every slice fits, newest filings first. Trademark and design searches return up to the 3,000 most recent matches per query, so add terms or a date window for older records. #### Can it look up a patent by number? Yes. Set `applicationNumber` to something like `2024-123456`. The number may carry a `JP` or `特願` prefix. #### Why do some records lack inventors or an abstract? J-PlatPat Crawler fills those from each document's own page, so they appear only when `fetchDetails` is on. Older utility models and some published applications do not carry every field, and the field is then empty. #### What does `status` mean? `Granted` means the patent has a registration number. `Published application` means it is published but not registered. Trademarks are `Registered` when they have a registration date and `Not registered` otherwise, which covers pending, refused and withdrawn applications. *** ### Need More Features? Need extra fields, filters or a different Japanese register? [File an issue](https://console.apify.com/actors/issues) or get in touch. ### Why Use J-PlatPat Crawler? - **Three registers, one actor** — Patents, utility models, trademarks and designs from the same official source, in one schema. - **Complete patent results** — Searches wider than the 3,000-row ceiling are split by filing date, so nothing is silently cut off. - **Document-level detail** — Inventors, IPC codes, claims count and abstract come with each patent, not just the search-hit columns. - **Ready for analysis** — ISO dates, normalised application numbers and arrays for applicants, inventors and codes. # Actor input Schema ## `sp_intended_usage` (type: `string`): What will this data feed? E.g. lead lists, KYB checks, price tracking. ## `sp_improvement_suggestions` (type: `string`): Provide any feedback or suggestions for improvements. ## `sp_contact` (type: `string`): We'll personally help with your use case. No spam. ## `searchType` (type: `string`): Kind of intellectual property to search. Patent covers patents and utility models. ## `searchQuery` (type: `string`): Keywords, separated by spaces (all must match; up to 4). Japanese text works best. For trademarks and designs this is matched against the mark or article name and the owner. ## `searchField` (type: `string`): Which part of a patent document the keywords must appear in. Patents only. ## `applicant` (type: `string`): Applicant or owner name in Japanese (partial names match). For trademarks and designs, used as the search when no query is set. ## `inventor` (type: `string`): Inventor name in Japanese (partial names match). Patents only. ## `ipcCode` (type: `string`): Patent classification code or prefix, for example H04L or G06N10/40. Patents only. ## `applicationNumber` (type: `string`): Look up one patent application, for example 2024-123456 or JP2024-123456. Overrides every other patent filter. Patents only. ## `niceClass` (type: `string`): Keep only trademarks registered in this Nice goods and services class. Trademarks only. ## `dateFrom` (type: `string`): Earliest filing date, YYYY-MM-DD. ## `dateTo` (type: `string`): Latest filing date, YYYY-MM-DD. ## `fetchDetails` (type: `boolean`): Add inventors, IPC codes, claims count, abstract, registration and priority data to each patent. Slower, as each patent needs extra lookups. ## `maxItems` (type: `integer`): Maximum number of records to return. ## Actor input object example ```json { "sp_contact": "Share your email here...", "searchType": "patent", "searchQuery": "量子", "searchField": "title", "niceClass": "", "fetchDetails": true, "maxItems": 10 } ``` # Actor output Schema ## `results` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "sp_contact": "Share your email here...", "searchType": "patent", "searchQuery": "量子", "searchField": "title", "niceClass": "", "fetchDetails": true, "maxItems": 10 }; // Run the Actor and wait for it to finish const run = await client.actor("jungle_synthesizer/j-platpat-patent-crawler").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "sp_contact": "Share your email here...", "searchType": "patent", "searchQuery": "量子", "searchField": "title", "niceClass": "", "fetchDetails": True, "maxItems": 10, } # Run the Actor and wait for it to finish run = client.actor("jungle_synthesizer/j-platpat-patent-crawler").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "sp_contact": "Share your email here...", "searchType": "patent", "searchQuery": "量子", "searchField": "title", "niceClass": "", "fetchDetails": true, "maxItems": 10 }' | apify call jungle_synthesizer/j-platpat-patent-crawler --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/j-platpat-patent-crawler" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/D7lrqaQuuKFIwMebu/builds/Tyoc9ye4Bvh9GlkWY/openapi.json