note非公式APIをPythonで叩く入門｜仕組み・準備・最初のリクエスト

# 仮想環境を作る（推奨）
python -m venv venv

# 有効化（Windows）
venv\Scripts\activate

# 有効化（macOS / Linux）
source venv/bin/activate

# 必要なライブラリ
pip install requests pandas python-dotenv

import requests

# 記事URLの末尾にある n で始まる文字列が「記事キー」
NOTE_KEY = "n6a10366298b0"

url = f"https://note.com/api/v3/notes/{NOTE_KEY}"

headers = {
    # User-Agent を付けないと弾かれる場合がある
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/120.0.0.0 Safari/537.36",
    "Accept": "application/json",
}

res = requests.get(url, headers=headers, timeout=15)

print("ステータスコード:", res.status_code)

if res.status_code == 200:
    data = res.json()
    print("トップレベルのキー:", list(data.keys()))
else:
    print("取得に失敗しました")
    print(res.text[:500])

import json
import requests

NOTE_KEY = "n6a10366298b0"
UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def fetch_note(note_key: str) -> dict:
    """記事1本を取得して data の中身を返す"""
    url = f"https://note.com/api/v3/notes/{note_key}"
    res = requests.get(url, headers={"User-Agent": UA}, timeout=15)
    res.raise_for_status()
    payload = res.json()
    # 多くのエンドポイントは data の中に本体が入っている
    return payload.get("data", payload)


def describe(obj, prefix="", max_depth=2, depth=0):
    """JSONの構造をざっと把握するための再帰プリンタ"""
    if depth > max_depth:
        return
    if isinstance(obj, dict):
        for key, value in obj.items():
            kind = type(value).__name__
            if isinstance(value, (dict, list)):
                size = len(value)
                print(f"{prefix}{key}: {kind}({size})")
                describe(value, prefix + "  ", max_depth, depth + 1)
            else:
                preview = str(value)
                if len(preview) > 40:
                    preview = preview[:40] + "..."
                print(f"{prefix}{key}: {kind} = {preview}")
    elif isinstance(obj, list) and obj:
        print(f"{prefix}[0]:")
        describe(obj[0], prefix + "  ", max_depth, depth + 1)


if __name__ == "__main__":
    note = fetch_note(NOTE_KEY)
    describe(note)

    # 全体をファイルに保存して、エディタで眺めるのが確実
    with open("note_sample.json", "w", encoding="utf-8") as f:
        json.dump(note, f, ensure_ascii=False, indent=2)
    print("\nnote_sample.json に保存しました")

import requests

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def get_note_ids(note_key: str) -> tuple:
    """記事キーから (数値id, key, タイトル) を取り出す"""
    url = f"https://note.com/api/v3/notes/{note_key}"
    res = requests.get(url, headers={"User-Agent": UA}, timeout=15)
    res.raise_for_status()
    data = res.json().get("data", {})
    return data.get("id"), data.get("key"), data.get("name")


if __name__ == "__main__":
    note_id, key, title = get_note_ids("n6a10366298b0")
    print(f"数値ID : {note_id}")
    print(f"キー   : {key}")
    print(f"タイトル: {title}")

import time
import requests

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")

SLEEP_SEC = 1.0  # 1リクエストごとに1秒待つ


def fetch_all_contents(urlname: str, max_pages: int = 20) -> list:
    """クリエイターの記事一覧をページングしながら全件取得する"""
    results = []
    page = 1

    while page <= max_pages:
        url = f"https://note.com/api/v2/creators/{urlname}/contents"
        params = {"kind": "note", "page": page}
        res = requests.get(url, params=params,
                           headers={"User-Agent": UA}, timeout=15)

        if res.status_code != 200:
            print(f"page {page} で停止: HTTP {res.status_code}")
            break

        data = res.json().get("data", {})
        contents = data.get("contents", [])
        if not contents:
            break

        results.extend(contents)
        print(f"page {page}: {len(contents)} 件取得（累計 {len(results)} 件）")

        # 最終ページ判定（フィールド名は変わる可能性があるため両対応）
        if data.get("isLastPage") or data.get("is_last_page"):
            break

        page += 1
        time.sleep(SLEEP_SEC)

    return results


if __name__ == "__main__":
    items = fetch_all_contents("marie_222")
    print(f"\n合計 {len(items)} 件")

    for item in items[:5]:
        print("-", item.get("name"))

import requests

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def search_notes(keyword: str, size: int = 10, sort: str = "popular") -> list:
    """
    note内をキーワード検索する
    sort: popular（人気） / hot（急上昇） / new（新着）
    """
    url = "https://note.com/api/v3/searches"
    params = {
        "context": "note",   # note / user / magazine / hashtag
        "q": keyword,
        "size": size,
        "start": 0,
        "sort": sort,
    }
    res = requests.get(url, params=params,
                       headers={"User-Agent": UA}, timeout=15)
    res.raise_for_status()

    data = res.json().get("data", {})
    notes = data.get("notes", {})
    return notes.get("contents", [])


if __name__ == "__main__":
    for item in search_notes("Python 自動化", size=10):
        title = item.get("name", "")
        likes = item.get("likeCount", item.get("like_count", 0))
        price = item.get("price", 0)
        tag = "有料" if price else "無料"
        print(f"[{tag}] スキ{likes:>4} | {title}")

import time
import requests

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def hashtag_info(tag: str) -> dict:
    """タグの記事数と関連タグを取得する"""
    url = f"https://note.com/api/v2/hashtags/{tag}"
    res = requests.get(url, headers={"User-Agent": UA}, timeout=15)
    res.raise_for_status()
    return res.json().get("data", {})


if __name__ == "__main__":
    targets = ["Python", "副業", "ブログ運営"]

    for tag in targets:
        info = hashtag_info(tag)
        hashtag = info.get("hashtag", info)
        name = hashtag.get("name", tag)
        count = hashtag.get("count", 0)
        print(f"#{name}: {count:,} 件")

        related = info.get("relatedHashtags", [])[:5]
        if related:
            names = ", ".join(f"#{r.get('name')}" for r in related)
            print(f"  関連: {names}")

        time.sleep(1.0)

"""
note非公式APIの共通クライアント
- リクエスト間隔の確保
- 429 / 5xx の自動リトライ（指数バックオフ）
- JSONの data 取り出しを共通化
"""
import time
import random
import logging

import requests

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
)
logger = logging.getLogger(__name__)

BASE_URL = "https://note.com"
DEFAULT_UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
              "AppleWebKit/537.36 (KHTML, like Gecko) "
              "Chrome/120.0.0.0 Safari/537.36")


class NoteClient:

    def __init__(self, interval: float = 1.2, max_retry: int = 3):
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": DEFAULT_UA,
            "Accept": "application/json",
        })
        self.interval = interval      # 最低リクエスト間隔（秒）
        self.max_retry = max_retry
        self._last_request_at = 0.0

    def _wait(self):
        """前回リクエストから interval 秒あけるまで待機する"""
        elapsed = time.time() - self._last_request_at
        if elapsed < self.interval:
            time.sleep(self.interval - elapsed)
        self._last_request_at = time.time()

    def request(self, method: str, path: str, **kwargs):
        """リトライ付きの共通リクエスト"""
        url = f"{BASE_URL}{path}"
        kwargs.setdefault("timeout", 20)

        for attempt in range(1, self.max_retry + 1):
            self._wait()
            try:
                res = self.session.request(method, url, **kwargs)
            except requests.RequestException as e:
                logger.warning("通信エラー(%s/%s): %s", attempt, self.max_retry, e)
                self._backoff(attempt)
                continue

            if res.status_code == 429:
                logger.warning("レート制限(429)。待機します")
                self._backoff(attempt, base=5.0)
                continue

            if 500 <= res.status_code < 600:
                logger.warning("サーバーエラー(%s)", res.status_code)
                self._backoff(attempt)
                continue

            return res

        raise RuntimeError(f"リトライ上限に達しました: {method} {path}")

    def _backoff(self, attempt: int, base: float = 1.5):
        """指数バックオフ（ジッター付き）"""
        wait = base * (2 ** (attempt - 1)) + random.uniform(0, 1.0)
        logger.info("%.1f 秒待機します", wait)
        time.sleep(wait)

    def get_json(self, path: str, params: dict = None) -> dict:
        """GETしてJSONの data を返す"""
        res = self.request("GET", path, params=params)
        if res.status_code != 200:
            logger.error("HTTP %s: %s", res.status_code, path)
            return {}
        try:
            payload = res.json()
        except ValueError:
            logger.error("JSONとして解釈できません: %s", path)
            return {}
        return payload.get("data", payload)

    # ---- 便利メソッド ----

    def get_note(self, note_key: str) -> dict:
        return self.get_json(f"/api/v3/notes/{note_key}")

    def get_creator(self, urlname: str) -> dict:
        return self.get_json(f"/api/v2/creators/{urlname}")

    def get_hashtag(self, tag: str) -> dict:
        return self.get_json(f"/api/v2/hashtags/{tag}")


if __name__ == "__main__":
    client = NoteClient()

    note = client.get_note("n6a10366298b0")
    print("タイトル:", note.get("name"))
    print("スキ数  :", note.get("like_count"))
    print("価格    :", note.get("price"))

import requests

from note_client import NoteClient

MESSAGES = {
    401: "ログインが必要なエンドポイントです。Cookieを設定してください",
    403: "権限がないか、その操作が許可されない条件に該当しています",
    404: "対象が見つかりません。keyとidを取り違えていないか確認してください",
    422: "送信内容に不備があります。必須フィールドを確認してください",
    429: "リクエストが多すぎます。間隔を広げてください",
}


def safe_get(client: NoteClient, path: str, params: dict = None):
    """ステータスコードに応じたメッセージを出しつつ取得する"""
    try:
        res = client.request("GET", path, params=params)
    except RuntimeError as e:
        print("リクエスト失敗:", e)
        return None

    if res.status_code == 200:
        return res.json().get("data")

    hint = MESSAGES.get(res.status_code, "想定外のエラーです")
    print(f"HTTP {res.status_code}: {hint}")
    print("レスポンス:", res.text[:300])
    return None


if __name__ == "__main__":
    client = NoteClient()

    # 存在しない記事キーを叩いてみる（404の確認）
    result = safe_get(client, "/api/v3/notes/nXXXXXXXXXXXX")
    print("結果:", result)

import csv
from datetime import datetime

from note_client import NoteClient


def collect_creator_notes(client: NoteClient, urlname: str,
                          max_pages: int = 10) -> list:
    """クリエイターの記事一覧を集める"""
    rows = []
    for page in range(1, max_pages + 1):
        data = client.get_json(
            f"/api/v2/creators/{urlname}/contents",
            params={"kind": "note", "page": page},
        )
        contents = data.get("contents", [])
        if not contents:
            break

        for item in contents:
            rows.append({
                "key": item.get("key", ""),
                "title": item.get("name", ""),
                "published": item.get("publishAt", item.get("publish_at", "")),
                "likes": item.get("likeCount", item.get("like_count", 0)),
                "price": item.get("price", 0),
                "url": f"https://note.com/{urlname}/n/{item.get('key', '')}",
            })

        print(f"page {page} 完了（累計 {len(rows)} 件）")

        if data.get("isLastPage") or data.get("is_last_page"):
            break

    return rows


def save_csv(rows: list, filename: str = None):
    if not rows:
        print("保存対象がありません")
        return

    if filename is None:
        stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"note_articles_{stamp}.csv"

    with open(filename, "w", encoding="utf-8-sig", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)

    print(f"{filename} に {len(rows)} 件を保存しました")


if __name__ == "__main__":
    client = NoteClient(interval=1.5)
    articles = collect_creator_notes(client, "marie_222")
    save_csv(articles)

def pick(data: dict, *keys, default=None):
    """
    複数の候補キーを順に試して、最初に見つかった値を返す。
    APIの表記ゆれ（camelCase / snake_case）対策。

    使い方:
        likes = pick(item, "likeCount", "like_count", default=0)
    """
    for key in keys:
        if key in data and data[key] is not None:
            return data[key]
    return default


if __name__ == "__main__":
    sample = {"like_count": 42, "name": "サンプル記事"}

    print(pick(sample, "likeCount", "like_count", default=0))  # 42
    print(pick(sample, "publishAt", "publish_at", default="不明"))  # 不明