# note.com Scraper: note 記事, Likes & Paid Prices (`kizukidata/note-articles-feed`) Actor

Scrape note.com articles (note 記事) by creator: one row per article: title, URL, published time, likes (スキ数), comments, hashtags, paid price and free text. The Only new articles option returns only articles added since your last run. No login; paid parts are never read. Not affiliated with note inc.

- **URL**: https://apify.com/kizukidata/note-articles-feed.md
- **Developed by:** [Kizuki](https://apify.com/kizukidata) (community)
- **Categories:** Social media, Automation, Marketing
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 articles

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

### What does note.com Scraper do?

**note.com Scraper** reads the public articles (note 記事) of note.com creators and companies and returns one row
per article: title, URL, publish time, likes (スキ数), comments, hashtags, whether the article is paid and its
price, the eyecatch image, and — on request — the free part of the article as plain text and as HTML. The creator's
profile (name, ID, followers, note count) is repeated on every one of their rows, so the dataset is one table.

No note.com account and no login. Only the article rows that come back are charged: a creator the run could not
read, an article a filter left out, and an article skipped as already returned (`onlyNewItems`) cost nothing.

#### 日本語の概要

note.com のクリエイター・企業の公開記事を、1 記事 1 行で返します（タイトル・URL・公開日時・スキ数・コメント数・ハッシュタグ・有料記事かどうかと価格・アイキャッチ・指定すれば無料部分の本文）。ログインは不要です。課金は返した記事の行だけで、読めなかったクリエイター・条件で外れた記事・`onlyNewItems` で前回までに返した記事として飛ばした分は無料です。定期実行して新しい記事だけを受け取ることもできます。

note.com Scraper is an independent tool. It is **not affiliated with, endorsed by or sponsored by** note.com.

### Use cases

- **定点観測 (new articles only).** Schedule a run with `onlyNewItems` and get only what a creator published since
  the previous run — one row per article, no duplicates.
- **記事の反応を見る.** Follow a creator's スキ数 and comment counts across articles to see which topics landed.
- **有料記事の調査.** See which articles are paid, at what price, and how much text sits behind the paywall
  (`paidPartCharCount`) before you subscribe or cite.
- **LLM と検索の材料.** `includeBody` returns the free part of each article as plain text and as HTML, ready to
  embed, index or summarise.
- **競合・媒体の定点調査.** Put up to 50 creators or company accounts in one run and keep one table.

### What data can you get?

| Group | Fields |
|---|---|
| Article | `id`, `noteKey`, `noteId`, `url`, `type`, `title`, `publishedAt` — `source` is the same on every row (`note.com`) |
| Engagement (at read time) | `likeCount` (スキ数), `commentCount` |
| Paid article | `isPaid`, `price` (JPY), `currency` (`JPY`), `paidPartCharCount` |
| Visual | `eyecatchUrl` |
| Tags | `hashtags` (stored without the leading `#`) |
| Creator (repeated on every row) | `creator`: `urlname`, `id`, `name`, `url`, `followers`, `noteCount`, `profileImageUrl` |
| Text (only with `includeBody`) | `body`, `bodyHtml`, `bodyChars`, `bodyTruncated`, `bodySource`, `bodyError` |

### How to use note.com Scraper

1. Put the creators into **Creators (note の ID・URL)** (`creators`): an ID (`notepro`), a profile URL
   (`note.com/notepro`) or an article URL (`note.com/notepro/n/n40849a7c492f`), at least one and up to
   50 per run.
2. Set **Maximum articles read per creator** (`maxArticlesPerCreator`: 1–200, newest first) and, if you want a window, **Only articles on
   or after this date**.
3. For monitoring, turn on **Only new articles** (`onlyNewItems`) and schedule the Actor. Each run then returns
   only the articles it has not returned before.
4. Run the Actor and read the dataset, or take the `body` field when **Include the article text** (`includeBody`) is on.

`{}` returns the newest articles of a public note.com creator (the sample is note's own company account,
`notepro`).

#### Input example

```json
{
    "creators": ["notepro", "https://note.com/notepro"],
    "maxArticlesPerCreator": 10,
    "since": "2026-11-01",
    "onlyNewItems": false,
    "includeBody": false,
    "maxItems": 20
}
```

### Input

| Field | Default | Meaning |
|---|---|---|
| `creators` | `notepro` | 1 to 50 creators or companies (an empty list is refused as invalid input): an ID (`notepro`), a profile URL (`note.com/notepro`) or an article URL (`note.com/notepro/n/n40849a7c492f`). Invalid entries are skipped and listed in OUTPUT; a creator with no published articles is listed there with that reason. |
| `maxArticlesPerCreator` | 10 | Articles read per creator, newest first, 1–200. Articles a date filter drops still count towards this limit. |
| `since` | empty | `YYYY-MM-DD` (UTC). Older articles are left out, and reading stops once a page is older than the date. Empty means no cutoff. |
| `onlyNewItems` | false | Return only articles that an earlier run of the same input did not return. The state is kept per creator and `since` for 90 days. |
| `includeBody` | false | Add the article text: the whole free part as plain text and as HTML, up to 50,000 characters each. One extra request per returned article, so a run with it on takes about a second per row longer. Off by default to keep rows small. |
| `maxItems` | 20 | Rows written per run, 1–1000, shared across creators. |

### Output

One row per article (the default dataset):

```json
{
    "id": "notepro/n40849a7c492f",
    "source": "note.com",
    "noteKey": "n40849a7c492f",
    "noteId": 185529192,
    "url": "https://note.com/notepro/n/n40849a7c492f",
    "type": "TextNote",
    "title": "リード獲得につながる記事とは？「AIに見つけてもらう」記事の3つの条件",
    "creator": {
        "urlname": "notepro",
        "id": 1734232,
        "name": "note pro公式 | 法人オウンドメディアをかんたん、すぐに立ち上げ",
        "url": "https://note.com/notepro",
        "followers": 36006,
        "noteCount": 561,
        "profileImageUrl": "https://assets.st-note.com/production/uploads/images/93752545/profile_50696d0056cf0fff4aadbc6562821dbb.png?fit=bounds&format=jpeg&quality=85&width=330"
    },
    "publishedAt": "2026-10-26T02:00:00.000Z",
    "likeCount": 39,
    "commentCount": 0,
    "hashtags": ["AI", "notepro"],
    "isPaid": false,
    "price": 0,
    "currency": "JPY",
    "eyecatchUrl": "https://assets.st-note.com/production/uploads/images/324291289/rectangle_large_type_2_51f622fef7af66f4aed0e75f5fd8c345.png?fit=bounds&quality=85&width=1280",
    "body": null,
    "bodyHtml": null,
    "bodyChars": null,
    "bodyTruncated": false,
    "paidPartCharCount": null,
    "bodySource": null,
    "bodyError": null
}
```

- `price` is in Japanese yen (`JPY`), `0` for a free article; `isPaid` is `true` when the price is above zero or
  note.com marks the article as not free.
- `publishedAt` is UTC; note.com itself serves the time with a `+09:00` offset.
- `isNew` appears only with `onlyNewItems`.
- The text fields are filled only with `includeBody: true`, and are `null` without it:
  - `body`: the whole free part as plain text, line breaks kept, up to 50,000 characters.
  - `bodyHtml`: the same free part as note.com's HTML (scripts, frames, event handlers and `javascript:` links
    removed), up to 50,000 characters — for readers that keep headings, bold and links.
  - `bodyChars`: characters in `body`; `bodyTruncated` is `true` when the 50,000 character cap cut either field.
  - For a paid article `body` is the free part note.com serves without login (the text stops at the paywall);
    the paid part is never fetched and `paidPartCharCount` is note.com's own count of it.
  - `bodySource` says where the text came from: `"article"` for the article's own text, `"preview"` when only
    the 240 character listing excerpt could be read. In that case `bodyError` gives the fixed reason, and the
    row is still returned and still charged (the article's metadata is real).

### How much does it cost?

note.com Scraper uses **pay-per-event** pricing: you pay only for the article rows returned, not for the time
it runs.

| Apify plan (discount tier) | Price per 1,000 articles | Price per article |
|---|---|---|
| **Free** | $2.00 | $0.002 |
| **Starter (Bronze)** | $1.80 | $0.0018 |
| **Scale (Silver)** | $1.50 | $0.0015 |
| **Business (Gold)** | $1.20 | $0.0012 |

Apify's Free plan includes USD 5 of monthly usage, which covers about 2,500 articles at the Free tier price,
run start fees aside.

- **Run start fee**: the platform default per run (see the Pricing tab).
- Only article rows are charged. Articles left out by `since`, articles already returned with `onlyNewItems`,
  unknown creators, and creators the run never reached are **not charged**.

### Use with AI agents (MCP)

note.com Scraper works as a tool for AI agents such as Claude, Cursor and n8n agents through the Apify MCP server. Load only this Actor with this server URL:

```text
https://mcp.apify.com?tools=kizukidata/note-articles-feed
```

- **Claude Code**: run `claude mcp add apify "https://mcp.apify.com?tools=kizukidata/note-articles-feed" -t http`.
- **Claude (web or desktop app)**: open **Customize → Connectors**, choose **Add custom connector**, name it `Apify` and paste the server URL above.
- **Cursor**: add the server to `~/.cursor/mcp.json` (or `.cursor/mcp.json` in a project):

```json
{
    "mcpServers": {
        "apify": { "url": "https://mcp.apify.com?tools=kizukidata/note-articles-feed" }
    }
}
```

- **n8n**: add the Apify node (on self-hosted n8n, install the community package `@apify/n8n-nodes-apify`) and choose **Run an Actor and get dataset**; for an n8n AI Agent, add **Apify Tool** as a tool.

The server signs you in to Apify with OAuth. A client that cannot use OAuth can send your Apify API token in an `Authorization: Bearer <APIFY_TOKEN>` header instead.

#### What to send from an agent

A monitoring call is one small input:

```json
{ "creators": ["notepro"], "maxItems": 20, "includeBody": false, "onlyNewItems": true }
```

Keep `maxItems` modest when an agent calls it: a row with `includeBody: true` costs one extra request, and the
agent rarely needs the full text of every article.

### Integrations and API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/kizukidata~note-articles-feed/runs" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"creators":["notepro"],"maxItems":20,"onlyNewItems":true}'
```

Poll `GET https://api.apify.com/v2/actor-runs/<RUN_ID>` for the status, read `defaultDatasetId`, then fetch
`GET https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json`.

#### n8n, Make and Zapier

Use the Apify integration, choose **Run Actor**, pass the creator list and `onlyNewItems: true`, then **Get
dataset items**. A schedule every hour with the same input returns only new articles, one row per article.

### Limitations

- **Named creators only.** The Actor tracks articles by creator and company profile; hashtag and keyword search
  are not supported.
- **The counts are the values at read time.** note.com can revoke an article after it was returned; such an
  article stays in an earlier dataset.
- **The paid part is never returned.** note.com serves the free preview to a visitor, so a paid article's `body`
  stops at the paywall and `paidPartCharCount` says how much is behind it.
- **A creator with 0 published articles** produces no dataset row: it is listed in OUTPUT `emptyInputs` with that reason, and nothing is charged.
- **`onlyNewItems` keeps one record per creator** in the named store `state-note-<actor id>`: the hashes of the
  articles already returned, with their note key and URL. A record is written only after the rows were written,
  so a failed run retries the articles. The record is kept for 90 days.
- **A preview fallback is still a charged row.** When only the 240 character listing excerpt can be read, the row
  comes back with `bodySource: "preview"` and `bodyError` set; the article's metadata is real, so the row is
  charged.

### FAQ

#### Which creators can I follow?

Any public note.com creator or company profile: an ID, a profile URL or one of its article URLs. Up to 50 entries
per run; invalid entries are skipped and named in OUTPUT, and so is a creator with nothing to return.

#### Why is a creator missing from the dataset?

Check the run's OUTPUT record. A name note.com does not know is listed under `skippedInputs` and is free. A
creator note.com has but with nothing to return (0 published articles, or an empty listing) is named under
`emptyInputs` with that reason, and is free too: nothing was returned and nothing was charged. A creator whose
articles all fall before `since`, or whose articles were already returned with `onlyNewItems`, writes no row
and is not a failure.

#### Why is `body` null although the run returned the article?

The text is only read with `includeBody: true`. Without it, `body`, `bodyHtml` and `bodyChars` stay `null` and
the row is still charged for the article metadata.

#### Why is a paid article's text shorter than the article?

note.com shows the free preview to a visitor. The Actor returns that preview and reports the rest through
`paidPartCharCount`; the paid part is never fetched.

#### Is it legal to use this data?

The Actor reads only publicly accessible profiles and articles, without login or an account. note.com's terms
restrict copying or reproduction beyond the scope of a personal subscription, so check those terms and the law
where you operate before you republish an article. This is not legal advice.

### Related Kizuki Actors

Other Actors from Kizuki that work well with this one:

- [Google News Scraper](https://apify.com/kizukidata/google-news-feed) — news coverage of the same company from the wider press.
- [Telegram Channel Scraper](https://apify.com/kizukidata/telegram-channel-feed) — channel posts from the same company or topic.

### Your feedback

Found a creator that should be read differently, or a field that is wrong? Open an Issue in this Actor's Issues
tab with the run ID. If you own a note.com account and want it excluded, name the creator ID in an Issue and it
is added to an opt-out list.

# Actor input Schema

## `creators` (type: `array`):

note.com creators or companies: an ID (notepro), a profile URL (https://note.com/notepro) or a note URL (https://note.com/notepro/n/n40849a7c492f). At least one, up to 50 per run. Invalid entries are skipped and listed in OUTPUT; an ID note.com does not know is reported as not found and is not charged. A creator with no published articles is listed in OUTPUT with that reason and is not charged either.

## `maxArticlesPerCreator` (type: `integer`):

How many of the creator's newest articles to read, from 1 to 200. Articles that since drops still count towards this limit (it bounds the work).

## `since` (type: `string`):

A date written as YYYY-MM-DD (UTC), or empty for no cutoff. Reading stops when the creator's page is older than the date, so a since date also keeps the run small.

## `onlyNewItems` (type: `boolean`):

Return only articles this input did not return in an earlier run. The state is kept per creator and since date for 90 days in a named key-value store. An article is remembered only after its row was written, so a failed run retries it.

## `includeBody` (type: `boolean`):

Return the article body as plain text and HTML, up to 50,000 characters each. A paid article carries only the free part that note.com shows without login; the paid part is never read, so it is never returned. Off by default to keep rows small.

## `maxItems` (type: `integer`):

Maximum rows written in one run, from 1 to 1000. The budget is shared across creators, so a small value still covers every creator.

## `proxyConfiguration` (type: `object`):

No proxy by default: public profiles and listings answer direct connections. Turn on an Apify datacenter proxy when your runs are rate-limited. Residential proxies are not available in this Actor.

## Actor input object example

```json
{
  "creators": [
    "notepro",
    "https://note.com/notepro"
  ],
  "maxArticlesPerCreator": 10,
  "since": "",
  "onlyNewItems": false,
  "includeBody": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Article rows returned by this run, one per article.

## `runSummary` (type: `string`):

Status code, counters, the skipped input entries (invalid, unknown, or with no articles), and the entries that were not checked.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "creators": [
        "notepro"
    ],
    "maxArticlesPerCreator": 10,
    "since": "",
    "onlyNewItems": false,
    "includeBody": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kizukidata/note-articles-feed").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "creators": ["notepro"],
    "maxArticlesPerCreator": 10,
    "since": "",
    "onlyNewItems": False,
    "includeBody": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kizukidata/note-articles-feed").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 '{
  "creators": [
    "notepro"
  ],
  "maxArticlesPerCreator": 10,
  "since": "",
  "onlyNewItems": false,
  "includeBody": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kizukidata/note-articles-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kizukidata/note-articles-feed"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/Un2LHIdrpO5weDDwh/builds/zcE6JAgTpC9yJNjT5/openapi.json