免费图库API全攻略：Unsplash、Pexels、Wikimedia接入实测

1

headers = {"Authorization": "Client-ID YOUR_ACCESS_KEY"}

1
2
3
4
5
6
7
8
9

# 获取 bearer token
response = requests.post("https://unsplash.com/oauth/token", data={
    "client_id": ACCESS_KEY,
    "client_secret": SECRET_KEY,
    "redirect_uri": REDIRECT_URI,
    "code": AUTH_CODE,
    "grant_type": "authorization_code"
})
token = response.json()["access_token"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import requests

ACCESS_KEY = "你的Access_Key"
BASE_URL = "https://api.unsplash.com"

def search_photos(query, per_page=10):
    """搜索 Unsplash 图片"""
    url = f"{BASE_URL}/search/photos"
    headers = {"Authorization": f"Client-ID {ACCESS_KEY}"}
    params = {
        "query": query,
        "per_page": per_page,
        "orientation": "landscape"  # landscape | portrait | squarish
    }
    
    resp = requests.get(url, headers=headers, params=params)
    data = resp.json()
    
    for photo in data["results"]:
        print(f"📷 {photo['alt_description']}")
        print(f"  作者: {photo['user']['name']} (@{photo['user']['username']})")
        print(f"  原图: {photo['urls']['raw']}")
        print(f"  下载: {photo['links']['download']}")
        print(f"  尺寸: {photo['width']}×{photo['height']}")
        print()
    
    return data["results"]

# 搜索"山水"
photos = search_photos("mountain landscape", per_page=5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

const ACCESS_KEY = "你的Access_Key";

async function searchPhotos(query, perPage = 10) {
  const url = new URL("https://api.unsplash.com/search/photos");
  url.searchParams.set("query", query);
  url.searchParams.set("per_page", perPage);
  url.searchParams.set("orientation", "landscape");

  const resp = await fetch(url, {
    headers: { Authorization: `Client-ID ${ACCESS_KEY}` }
  });
  const data = await resp.json();

  return data.results.map(photo => ({
    id: photo.id,
    description: photo.alt_description,
    author: photo.user.name,
    authorUrl: photo.user.links.html,
    rawUrl: photo.urls.raw,
    downloadUrl: photo.links.download,
    width: photo.width,
    height: photo.height
  }));
}

// 使用
searchPhotos("city skyline").then(console.log);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 原图
https://images.unsplash.com/photo-1506744038136-46273834b3fb

# 裁剪为 800×600
https://images.unsplash.com/photo-1506744038136-46273834b3fb?w=800&h=600&fit=crop

# WebP 格式自动选择
https://images.unsplash.com/photo-1506744038136-46273834b3fb?w=800&fm=webp

# 降低质量以加快加载
https://images.unsplash.com/photo-1506744038136-46273834b3fb?w=800&q=75

1
2
3
4
5

resp = requests.get("https://api.unsplash.com/search/photos?query=test", 
                     headers={"Authorization": f"Client-ID {ACCESS_KEY}"})

print(f"限额: {resp.headers['X-Ratelimit-Limit']}")
print(f"剩余: {resp.headers['X-Ratelimit-Remaining']}")

1

headers = {"Authorization": "YOUR_API_KEY"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import requests

API_KEY = "你的API_Key"
BASE_URL = "https://api.pexels.com/v1"

def search_photos(query, per_page=15):
    """搜索 Pexels 图片"""
    url = f"{BASE_URL}/search"
    headers = {"Authorization": API_KEY}
    params = {
        "query": query,
        "per_page": per_page,
        "orientation": "landscape",  # landscape | portrait | square
        "size": "large",              # large(24MP) | medium(12MP) | small(4MP)
        "locale": "zh-CN"             # 中文搜索结果
    }

    resp = requests.get(url, headers=headers, params=params)
    data = resp.json()

    for photo in data["photos"]:
        print(f"📷 摄影: {photo['photographer']}")
        print(f"   原图: {photo['src']['original']}")
        print(f"   大图: {photo['src']['large2x']}")
        print(f"   横图: {photo['src']['landscape']}")
        print(f"   主色: {photo['avg_color']}")
        print(f"   尺寸: {photo['width']}×{photo['height']}")
        print()

    return data["photos"]

photos = search_photos("城市夜景", per_page=5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def search_videos(query, per_page=10):
    """搜索 Pexels 视频"""
    url = f"{BASE_URL}/videos/search"
    headers = {"Authorization": API_KEY}
    params = {
        "query": query,
        "per_page": per_page,
        "size": "large",       # large(4K) | medium(Full HD) | small(HD)
        "locale": "zh-CN"
    }

    resp = requests.get(url, headers=headers, params=params)
    data = resp.json()

    for video in data["videos"]:
        print(f"🎬 {video['url']}")
        print(f"   时长: {video['duration']}s")
        # 获取最高清的视频文件
        best = max(video["video_files"], key=lambda f: f.get("width", 0) * f.get("height", 0))
        print(f"   画质: {best['width']}×{best['height']}")
        print(f"   链接: {best['link']}")
        print()
    
    return data["videos"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

const API_KEY = "你的API_Key";

async function searchPexels(query, perPage = 15) {
  const url = new URL("https://api.pexels.com/v1/search");
  url.searchParams.set("query", query);
  url.searchParams.set("per_page", perPage);
  url.searchParams.set("orientation", "landscape");

  const resp = await fetch(url, {
    headers: { Authorization: API_KEY }
  });
  const data = await resp.json();

  return data.photos.map(p => ({
    id: p.id,
    photographer: p.photographer,
    url: p.src.original,
    large: p.src.large2x,
    avgColor: p.avg_color,
    width: p.width,
    height: p.height
  }));
}

1
2
3
4

import requests

# 不需要任何认证
url = "https://commons.wikimedia.org/w/api.php"

1
2
3

headers = {
    "User-Agent": "MyApp/1.0 (https://myapp.com; [email protected])"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import requests

def search_commons_images(query, limit=20):
    """搜索 Wikimedia Commons 图片"""
    url = "https://commons.wikimedia.org/w/api.php"
    params = {
        "action": "query",
        "list": "search",
        "srsearch": query,
        "srnamespace": 6,           # File 命名空间
        "srlimit": limit,
        "srprop": "size|wordcount|timestamp",
        "format": "json"
    }
    headers = {
        "User-Agent": "ContentTool/1.0 ([email protected])"
    }

    resp = requests.get(url, params=params, headers=headers)
    data = resp.json()

    titles = [item["title"] for item in data["query"]["search"]]
    return titles

# 搜索
titles = search_commons_images("Great Wall of China", limit=10)
print(titles)
# ['File:The Great Wall of China at Jinshanling.jpg', ...]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

def get_image_info(file_titles):
    """获取图片的 URL 和详细信息"""
    url = "https://commons.wikimedia.org/w/api.php"
    params = {
        "action": "query",
        "titles": "|".join(file_titles),
        "prop": "imageinfo",
        "iiprop": "url|size|extmetadata|user|timestamp|mime",
        "format": "json"
    }
    headers = {"User-Agent": "ContentTool/1.0 ([email protected])"}

    resp = requests.get(url, params=params, headers=headers)
    data = resp.json()

    results = []
    for page_id, page in data["query"]["pages"].items():
        if "imageinfo" not in page:
            continue
        info = page["imageinfo"][0]
        meta = info.get("extmetadata", {})

        # 提取版权信息
        license_name = meta.get("LicenseShortName", {}).get("value", "未知")
        license_url = meta.get("LicenseUrl", {}).get("value", "")
        attribution = meta.get("Attribution", {}).get("value", "")
        artist = meta.get("Artist", {}).get("value", "")

        results.append({
            "title": page["title"],
            "url": info["url"],
            "width": info["width"],
            "height": info["height"],
            "size_bytes": info["size"],
            "mime": info["mime"],
            "license": license_name,
            "license_url": license_url,
            "attribution": attribution,
            "artist": artist,
            "user": info.get("user", "")
        })

    return results

# 组合使用
titles = search_commons_images("sakura japan", limit=10)
images = get_image_info(titles)

for img in images:
    print(f"📷 {img['title']}")
    print(f"   图片: {img['url']}")
    print(f"   尺寸: {img['width']}×{img['height']}")
    print(f"   授权: {img['license']} → {img['license_url']}")
    print(f"   署名: {img['attribution'] or img['artist']}")
    print()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

def search_with_images(query, limit=10):
    """一步完成搜索+获取图片信息"""
    url = "https://commons.wikimedia.org/w/api.php"
    params = {
        "action": "query",
        "generator": "search",
        "gsrsearch": query,
        "gsrnamespace": 6,
        "gsrlimit": limit,
        "prop": "imageinfo",
        "iiprop": "url|size|extmetadata|user",
        "format": "json"
    }
    headers = {"User-Agent": "ContentTool/1.0 ([email protected])"}

    resp = requests.get(url, params=params, headers=headers)
    data = resp.json()

    results = []
    for page_id, page in data.get("query", {}).get("pages", {}).items():
        if "imageinfo" not in page:
            continue
        info = page["imageinfo"][0]
        meta = info.get("extmetadata", {})
        results.append({
            "title": page["title"],
            "url": info["url"],
            "license": meta.get("LicenseShortName", {}).get("value", "CC BY-SA"),
            "attribution": meta.get("Attribution", {}).get("value", "")
        })
    return results

images = search_with_images("Eiffel Tower sunset")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

import hashlib
import os
import time
import requests

class ImageBatcher:
    """批量图片获取 + 本地缓存"""
    
    def __init__(self, cache_dir="./image_cache"):
        self.cache_dir = cache_dir
        os.makedirs(cache_dir, exist_ok=True)
    
    def _cache_key(self, url):
        return hashlib.md5(url.encode()).hexdigest()
    
    def batch_search(self, api_func, keywords, per_keyword=5, 
                     min_ratio=1.3, max_ratio=2.5):
        """
        批量搜索 + 宽高比筛选
        
        Args:
            api_func: 搜索函数，返回图片列表
            keywords: 关键词列表，如 ["mountain", "city", "ocean"]
            per_keyword: 每个关键词取几张
            min_ratio/max_ratio: 宽高比范围（1.3-2.5 适合文章横幅）
        """
        results = {}
        
        for kw in keywords:
            try:
                photos = api_func(kw, per_page=per_keyword * 2)
                filtered = []
                
                for p in photos:
                    ratio = p["width"] / p["height"]
                    if min_ratio <= ratio <= max_ratio:
                        filtered.append(p)
                        if len(filtered) >= per_keyword:
                            break
                
                results[kw] = filtered
                print(f"✅ {kw}: 找到 {len(filtered)} 张合适图片")
                time.sleep(1)  # 礼貌间隔
                
            except Exception as e:
                print(f"❌ {kw}: {e}")
        
        return results
    
    def download_and_cache(self, photo_url, download_url=None):
        """
        下载并缓存图片到本地
        
        Unsplash 要求记录下载事件（通过 download_location 端点），
        这里一并处理。
        """
        cache_path = os.path.join(self.cache_dir, 
                                   f"{self._cache_key(photo_url)}.jpg")
        
        if os.path.exists(cache_path):
            return cache_path  # 命中缓存
        
        # Unsplash: 需要先触发 download 事件（合规）
        if download_url:
            requests.get(download_url)
        
        resp = requests.get(photo_url, stream=True)
        with open(cache_path, "wb") as f:
            for chunk in resp.iter_content(8192):
                f.write(chunk)
        
        return cache_path


# 使用示例
batcher = ImageBatcher()

keywords = ["mountain sunrise", "office workspace", "ocean waves"]
photos = batcher.batch_search(search_unsplash, keywords, per_keyword=3)

for kw, p_list in photos.items():
    for p in p_list:
        path = batcher.download_and_cache(p["url"], p.get("download_url"))
        print(f"  💾 {kw} → {path}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def check_license(image_info):
    """判断图片是否可以安全商用"""
    license_name = image_info.get("license", "")
    
    friendly_licenses = ["CC0", "Public domain", "CC BY 2.0", 
                         "CC BY 3.0", "CC BY 4.0", "CC BY-SA 2.0",
                         "CC BY-SA 3.0", "CC BY-SA 4.0"]
    
    restricted = ["CC BY-NC", "CC BY-ND", "CC BY-NC-SA", 
                  "CC BY-NC-ND", "All rights reserved"]
    
    if any(l.lower() in license_name.lower() for l in restricted):
        return "⚠️ 限制使用"
    
    if any(l.lower() in license_name.lower() for l in friendly_licenses):
        if "BY" in license_name:
            attribution = image_info.get("attribution", "未知作者")
            return f"✅ 可商用，署名: {attribution}"
        return "✅ 可自由使用（CC0/公有领域）"
    
    return f"❓ 请手动检查: {license_name}"